﻿#define _CRT_SECURE_NO_WARNINGS 1

//MT1001
//程序设计入门
//欢迎来到程序设计的世界，请编写一个简单程序，输出2行字符，第一行为“This is my first program!”，第二行为“Coding is fun!”
//
//格式
//输入格式：
//无
//
//输出格式：
//第一行为“This is my first program!”，第二行为“Coding is fun!”

#include<stdio.h>

int main()
{
    printf("This is my first program!\nCoding is fun!");
    return 0;
}

//MT1002
//输入和输出整型数据
//请编写一个简单程序，用户输入一个整数存储在变量中，并输出在屏幕上。
//
//格式
//输入格式：
//一个整型数据
//
//输出格式：
//输出You entered : 刚才输入的整型数据
#include<stdio.h>

int main()
{
    int num;
    scanf("%d", &num);
    printf("You entered:%d", num);
    return 0;
}

//MT1003
//整数运算
//请编写一个简单程序，用户输入2个整型数据存储在变量中，并输出他们的和与差。
//
//格式
//输入格式：
//2个整型数据，用逗号分隔
//
//输出格式：
//输出分两行，分别输出他们的和与差
#include<stdio.h>
int main()
{
    int a, b;
    scanf("%d,%d", &a, &b);
    printf("%d+%d=%d\n", a, b, a + b);
    printf("%d-%d=%d", a, b, a - b);
    return 0;
}

//MT1004
//求余
//请编写一个简单程序，用户输入2组整型数据存储在变量中，并输出两组数相除的余数。（不考虑除数为0）
//
//格式
//输入格式：
//输入2组整型数据，用空格分隔
//
//输出格式：
//输出分两行，分别输出两组数相除的余数

#include<stdio.h>
int main()
{
    int a, b, x, y;
    scanf("%d %d", &a, &b);
    scanf("%d %d", &x, &y);
    printf("%d%%%d=%d\n", a, b, a % b);
    printf("%d%%%d=%d\n", x, y, x % y);
    return 0;
}

//MT1005
//输入和输出实型数据
//请编写一个简单程序，用户输入一个float型数据和一个double型数据，存储在变量中，并输出在屏幕上。
//
//格式
//输入格式：
//第一个是float型数据，第二个是double型数据，用空格分隔
//
//输出格式：
//输出You entered : … and …(…处依序输出刚才输入的数据），第一个float型数据保留2位小数，第二个double型数据保留3位小数


#include<stdio.h>
int main()
{
    float a;
    double b;
    scanf("%f %lf", &a, &b);
    printf("You entered:%.2f and %.3lf", a, b);
    return 0;
}

//MT1006
//实型数运算
//请编写一个简单程序，用户输入2个实型数据存储在变量中，并输出他们的乘积与商。（本题不考虑除数为0的情况）
//
//格式
//输入格式：
//2个实型数据，用空格分隔
//
//输出格式：
//输出分两行，分别输出他们的乘积与商
#include<stdio.h>
int main()
{
    double a, b;
    scanf("%lf %lf", &a, &b);
    printf("%lf*%lf=%lf\n", a, b, a * b);
    printf("%lf/%lf=%lf", a, b, a / b);

    return 0;
}

//MT1007
//平均分
//输入一名学生的C++、python和C语言成绩，输出总分和和平均分。不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入为实型，空格分隔
//
//输出格式：
//输出为实型，保留6位小数

#include<stdio.h>
int main()
{
    double c_plus, python, c;
    scanf("%lf %lf %lf", &c_plus, &python, &c);
    double sum = c_plus + python + c;
    double ave = sum / 3;
    printf("%.6lf\n%.6lf", sum, ave);
    return 0;
}


//MT1008
//圆球等的相关计算
//请编写一个简单程序，输入半径和高，输出圆周长，圆面积，球面积，球体积，圆柱体积。(PI = 3.1415926)
//
//格式
//输入格式：
//输入为double型
//
//输出格式：
//分行输出，保留2位小数

#include<stdio.h>
int main()
{
    double PI = 3.1415926;
    double radius, high;
    scanf("%lf %lf", &radius, &high);
    printf("%.2lf\n%.2lf\n%.2lf\n%.2lf\n%.2lf", 2 * PI * radius, PI * radius * radius, 4 * PI * radius * radius, 4.0 / 3.0 * PI * radius * radius * radius, PI * radius * radius * high);
    return 0;
}

//MT1009
//公式计算
//计算公式
//(1 / 2)∗(a∗x + (a + x) / (4∗a))
//
//格式
//输入格式：
//输入为整型x, a，空格分隔
//
//输出格式：
//输出为实型，保留2位小数

#include<stdio.h>
int main()
{
    double x, a, result;
    scanf("%lf %lf", &x, &a);
    result = (1.0 / 2.0) * (a * x + (a + x) / (4.0 * a));
    printf("%.2lf", result);
    return 0;
}


//MT1010
//输入和输出字符型数据
//请编写一个简单程序，用户输入2个的字符型数据存储在变量中，并分别以字符形式和整数形式输出在屏幕上。
//
//格式
//输入格式：
//2个的字符型数据，用逗号分隔
//
//输出格式：
//输出两行The ASCII code of… is …(…处依次输出刚才输入的数据字符形式和整数形式）


#include<stdio.h>
    int main()
{
    char character1, character2;
    scanf("%c,%c", &character1, &character2);
    printf("The ASCII code of %c is %d\n", character1, character1);
    printf("The ASCII code of %c is %d ", character2, character2);
    return 0;
}

//MT1011
//字符和整数
//
//
//输出’X’、65的字符、十进制数据形式。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出字符、十进制整数，空格分隔


#include<stdio.h>
int main()
{
    char character = 'X';
    int integer = 65;
    printf("%c %d\n%c %d", character, character, integer, integer);
    return 0;
}

//MT1012
//各种类型长
//请编写一个简单程序，输出int、float、double和char的大小。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出分4行，分别输出int、float、double和char的大小

#include<stdio.h>
int main()
{
    printf("Size of int: %d bytes\n", sizeof(int));
    printf("Size of float: %d bytes\n", sizeof(float));
    printf("Size of double: %d bytes\n", sizeof(double));
    printf("Size of char: %d byte\n", sizeof(char));
    return 0;
}



//MT1013
//关键字long
//请编写一个简单程序，输出int、long int、long long int、double和long double的大小。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出分5行，分别输出int、long int、long long int、double和long double的大小
#include<stdio.h>
int main()
{
    printf("Size of int = %d bytes\n", sizeof(int));
    printf("Size of long int = %d bytes\n", sizeof(long int));
    printf("Size of long long int = %d bytes\n", sizeof(long long int));
    printf("Size of double = %d bytes\n", sizeof(double));
    printf("Size of long double = %d bytes\n", sizeof(long double));
    return 0;
}


//MT1014
//日期
//编写一个程序，以月 / 日 / 年（mm / dd / yyyy）的形式输入日期（其中月，日为1 - 2位整数，年为1 - 4位整数），然后以yyyymmdd的形式显示（其中月，日为2位整数，年为4位整数）。不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int a, b, c;
    scanf("%d/%d/%d", &a, &b, &c);
    printf("%0*d%0*d%0*d", 4, c, 2, a, 2, b);
    return 0;
}


//MT1015
//输入分隔符
//输入“a = 22, b = b, c = 14, d = d”给变量a、b、c、d，然后再输出他们。
//
//格式
//输入格式：
//a = 22, b = b, c = 14, d = d
//
//输出格式：
//空格分隔

#include<stdio.h>
int main()
{
    int a, c;
    char b, d;
    scanf("a=%d,b=%c,c=%d,d=%c", &a, &b, &c, &d);
    printf("%d %c %d %c", a, b, c, d);
    return 0;
}


//MT1016
//宽度与对齐
//输出455、 - 123、987654，宽度为5，分别左对齐和右对齐
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为整型，空格分隔。每个数的输出占一行

#include<stdio.h>
int main()
{
    int a = 455;
    int b = -123;
    long int c = 987654;
    printf("%-5d %5d\n", a, a);
    printf("%-5d %5d\n", b, b);
    printf("%-5d %5d\n", c, c);
    return 0;
}

//MT1017
//左右对齐
//输出3.1415926、22.3456，宽度为14，精度为6，分别左对齐和右对齐。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为实型，空格分隔。每个数的输出占一行。

#include<stdio.h>
int main()
{
    double a = 3.1415926;
    double b = 22.3456;
    printf("%-14.6lf %14.6lf\n", a, a);
    printf("%-14.6lf %14.6lf\n", b, b);
    return 0;
}


//MT1018
//输入宽度
//输入123456789给变量a1、a2、a3，宽度为3，然后输出a1、a2、a3，空格分隔。
//
//格式
//输入格式：
//123456789
//
//输出格式：
//输出为整型，空格分隔。

#include<stdio.h>
int main()
{
    int a, b, c;
    scanf("%3d%3d%3d", &a, &b, &c);
    printf("%d %d %d\n", a, b, c);
    return 0;
}

//MT1019
//宽度精度
//输出18.16054、17.676767，宽度和精度由输入决定，右对齐。
//
//格式
//输入格式：
//输入为宽度和精度整型，空格分隔。
//
//输出格式：
//输出为实型，空格分隔。



#include<stdio.h>
int main()
{
    int m, n;
    scanf("%d %d", &m, &n);
    printf("%*.*lf %*.*lf", m, n, 18.16054, m, n, 17.676767);

    return 0;
}


//MT1020
//% s格式符
//输入字符串，然后输出前3个字符，要求占6列，右对齐。
//
//格式
//输入格式：
//输入字符串
//
//输出格式：
//输出字符串
#include<stdio.h>
int main()
{
    char arr[10];
    // scanf("%s", &arr);
    gets(arr);
    printf("%6.3s", arr);
    return 0;
}


//MT1021
//% f格式符
//输入一个实数，第一次按实型输出；第二次保留2位小数输出；第三次保留3位小数但最小列宽8列输出，空格分隔。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出实型，空格分隔。

#include<stdio.h>
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%lf %.2lf %8.3lf", x, x, x);
    return 0;
}

//MT1022
//小数、指数
//输出3.1415926、12345678.123456789的小数、指数形式。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为实型，空格分隔

#include<stdio.h>
int count(int x)
{
    int count = 0;
    while (x / 10 != 0)
    {
        x = x / 10;
        count++;
    }
    return count;
}

int main()
{
    double x1 = 3.1415926;
    double x2 = 12345678.123456789;

    double x3 = x2;
    while ((int)x3 != 1)
    {
        x3 = x3 / 10;
    }

    printf("%lf %.6lfe+%0*d\n", x1, x1, 3, count(x1));
    printf("%lf %.6lfe+%0*d\n", x2, x3, 3, count(x2));
    return 0;
}



//MT1023
//进制乱炖
//输入一个正整数，输出它的十进制形式、八进制形式、十六进制形式（小写）、无符号的十进制形式，空格分隔。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int main()
{
    int x;
    scanf("%d", &x);
    printf("%d %o %x %u", x, x, x, x);
    return 0;
}


//MT1024
//进制形式
//分别输出128、456789的十进制、八进制、十六进制（字母大写）数据形式。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为整型，空格分隔

#include<stdio.h>
int main()
{
    printf("%d %o %X\n", 128, 128, 128);
    printf("%d %o %X", 456789, 456789, 456789);
    return 0;
}


//MT1025
//八、十六进制
//输出202、117、70、130的十进制、八进制、十六进制数据形式，结果为0ddddd或0Xddddd。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为整型，空格分隔。每个数的输出占一行。

#include<stdio.h>
int main()
{
    int x1 = 202, x2 = 117, x3 = 70, x4 = 130;
    printf("%d %#o %#X\n", x1, x1, x1);
    printf("%d %#o %#X\n", x2, x2, x2);
    printf("%d %#o %#X\n", x3, x3, x3);
    printf("%d %#o %#X\n", x4, x4, x4);
    return 0;
}

//MT1026
//合并
//已知a、b、c是一个十进制数的百位、十位、个位，求这个十进制数。
//
//格式
//输入格式：
//输入为正整型a、b、c，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    printf("%d\n", 100 * a + 10 * b + c);
    return 0;
}


//MT1027
//整数逆序
//编写一个程序，要求输入一个两位数的数字，然后逆序输出数字。不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入正整数
//
//输出格式：
//输出为逆序后的字符串


#include<stdio.h>
int main()
{
    int num, a, b;
    scanf("%d", &num);
    a = num / 10;
    b = num % 10;
    printf("%d%d", b, a);
    return 0;
}

//MT1028
//四位数逆序
//将一个四位数正整数（如1278）逆序（如8721）输出。不考虑负数等特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为逆序后的字符串


#include<stdio.h>
int main()
{
    int x, a, b, c, d;
    scanf("%d", &x);
    a = x % 10;
    b = x % 100 / 10;
    c = x / 100 % 10;
    d = x / 1000;
    printf("%d%d%d%d", a, b, c, d);
    return 0;
}

//MT1029
//位数
//编写一个程序，计算一个数字包含多少位数。您可以假定该数字不超过四位数。本题不考虑负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int x, count = 1;
    scanf("%d", &x);
    for (int i = 0; i < 4; i++)
    {
        if (x / 10 != 0)
        {
            x /= 10;
            count++;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1030
//最大公约数
//请编写一个简单程序，输入2个整数，输出他们的最大公约数。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int x, y, num;
    scanf("%d %d", &x, &y);
    for (int i = 1; i <= x && i <= y; i++)
    {
        if (x % i == 0 && y % i == 0)
        {
            num = i;
        }
    }
    printf("%d\n", num);
    return 0;
}

//MT1031
//最简分数
//编写一个程序，输入一个分数，然后输出它的最简分数。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int x, y, num, i;
    scanf("%d/%d", &x, &y);
    for (i = 1; i <= x && i <= y; i++)
    {
        if (x % i == 0 && y % i == 0)
        {
            num = i;
        }
    }
    printf("%d/%d\n", x / num, y / num);
    return 0;
}

//MT1032
//最小公倍数
//请编写一个简单程序，输入2个整数，输出他们的小公倍数。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int x, y, num;
    scanf("%d %d", &x, &y);
    printf("%d\n", x * y);
    return 0;
}

//MT1033
//多项式计算
//计算公式
//�
//6
//−
//2
//∗
//�
//5
//+
//3
//∗
//�
//4
//−
//5
//∗
//�
//2
//+
//6
//∗
//�
//+
//7
//x
//6
//−2∗x
//5
//+ 3∗x
//4
//−5∗x
//2
//+ 6∗x + 7
//
//格式
//输入格式：
//输入为整型x
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int x;
    scanf("%d", &x);
    printf("%d\n", x * x * x * x * x * x - 2 * x * x * x * x * x + 3 * x * x * x * x - 5 * x * x + 6 * x + 7);
    return 0;
}

//MT1034
//偶数平方
//编写一个程序，输入数字n，然后打印1和n之间的哪些是偶数平方的数。不考虑负数，0或者其他特殊情况。不考虑溢出或者超出整型范围的情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型，每个数字占一行

#include<stdio.h>
int main()
{
    int n, i;
    scanf("%d", &n);
    for (i = 1; i <= n / 10; i++)
    {
        if (i % 2 == 0 && i * i <= n)
        {
            printf("%d\n", i * i);
        }
    }
    return 0;
}


//MT1035
//奇数平方
//编写一个程序，输入数字n，然后打印1和n之间的那些是奇数平方的数。不考虑负数，0或者其他特殊情况。不考虑溢出或者超出整型范围的情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型，每个数字占一行

#include<stdio.h>
int main()
{
    int n, i;
    scanf("%d", &n);
    for (i = 1; i <= n / 10; i++)
    {
        if (i % 2 == 1 && i * i <= n)
        {
            printf("%d\n", i * i);
        }
    }
    return 0;
}

//MT1036
//和的立方
//输入为整数x，y，求x、y之和的立方。不考虑溢出等特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int x, y;
    scanf("%d %d", &x, &y);
    printf("%d\n", (x + y) * (x + y) * (x + y));
    return 0;
}

//MT1037
//绝对值
//输入数字a并计算a的绝对值。不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入实型数字a
//
//输出格式：
//输出a的绝对值，输出为实型


#include<stdio.h>
#include<math.h>
int main()
{
    double a;
    scanf("%lf", &a);
    printf("%lf\n", sqrt(a * a));
    return 0;
}

//MT1038
//交换输出
//请编写一个简单程序，输入两个整数a，b，交换他们的值并输出。
//
//格式
//输入格式：
//输入为int，空格分隔
//
//输出格式：
//输出为int，空格分隔


#include<stdio.h>
int main()
{
    int a, b, temp;
    scanf("%d %d", &a, &b);
    temp = a;
    a = b;
    b = temp;
    printf("%d %d", a, b);
    return 0;
}

//MT1039 偶数位
//（1）题目
//输入一个数字N，把偶数位置的所有数更改为0。比如30，二进制形式是11110, 替换后是01010，则输出对应的十进制整数10。最右边是第0位，从右向左依次为0位，1位等等。不考虑非法输入等特殊情况。
//
//格式
//
//输入格式 :
//输入为整型
//
//输出格式 :
//输出为整型

//样例1
//
//输入格式 :
//30
//
//输出格式 :
////    10

//    （2）参考代码

#include<stdio.h>
    int main()
{
    int N;
    scanf("%d", &N);
    int ID = 0, ch = 1, temp = N;
    while (temp)
    {
        if (ID % 2 == 0 && temp % 2 == 1)
        {
            N = N - ch;
        }
        temp = temp / 2;
        ch = 2 * ch;
        ID++;
    }
    printf("%d\n", N);
    return 0;
}

//MT1040 奇数位
//（1）题目
//输入一个数字N，把奇数位置的所有数更改为0。比如30，二进制形式是11110，替换后是10100，则输出对应的十进制整数20。最右边是第0位，从右向左依次为0位，1位等等。不考虑非法输入等特殊情况。
//
//格式
//
//输入格式 :
//输入为整型
//
//输出格式 :
//输出为整型
//样例1
//
//输入格式 :
//30
//
//输出格式 :
//    20

    （2）参考代码

#include<stdio.h>
    int main()
{
    int N;
    scanf("%d", &N);
    int ID = 0, ch = 1, temp = N;
    while (temp)
    {
        if (ID % 2 == 1 && temp % 2 == 1)
        {
            N = N - ch;
        }
        temp /= 2;
        ch *= 2;
        ID++;
    }
    printf("%d\n", N);
    return 0;
}



//MT1041
//求圆面积和周长
//请编写一个简单程序，输入半径，输出圆面积和周长。（PI是3.1415926）
//
//格式
//输入格式：
//double型
//
//输出格式：
//分2行输出圆面积和周长，保留6位小数


#include<stdio.h>
int main()
{
    double x, area, perimeter;
    double PI = 3.1415926;
    scanf("%lf", &x);
    area = PI * x * x;
    perimeter = 2 * PI * x;
    printf("Area=%.6lf\nCircumference=%.6lf", area, perimeter);
    return 0;
}



//MT1042
//求矩形的面积和周长
//请编写一个简单程序，输入矩形的长度和宽度，输出矩形的面积和周长。
//
//格式
//输入格式：
//实型，空格分隔
//
//输出格式：
//分2行输出矩形的面积和周长，保留6位小数
#include<stdio.h>
int main()
{
    double x, y;
    scanf("%lf %lf", &x, &y);
    printf("Area=%.6lf\nPerimeter=%.6lf", x * y, 2 * (x + y));
    return 0;
}

//MT1043
//椭圆计算
//请编写一个简单程序，输入长半轴和短半轴长度，计算输出椭圆的面积。（PI是3.1415926）
//
//格式
//输入格式：
//double型，空格分隔
//
//输出格式：
//输出椭圆的面积，保留6位小数


#include<stdio.h>
int main()
{
    double a, b;
    double PI = 3.1415926;
    scanf("%lf %lf", &a, &b);
    printf("Area = %.6lf", PI * a * b);
    return 0;
}

//MT1044
//三角形面积
//请编写一个简单程序，计算给定底面和高度的三角形面积。
//
//格式
//输入格式：
//输入float型，空格分隔
//
//输出格式：
//输出三角形面积，保留2位小数

#include<stdio.h>
int main()
{
    float a, b;
    scanf("%f %f", &a, &b);
    printf("Area=%.2f", 1.0 / 2.0 * a * b);
    return 0;
}

//MT1045
//平行四边形
//请编写一个简单程序，输入平行四边形底和高，输出平行四边形面积。不考虑非法输入。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型

#include<stdio.h>
int main()
{
    double a, b;
    scanf("%lf %lf", &a, &b);
    printf("%lf", a * b);
    return 0;
}



//MT1046
//菱形
//输入菱形的两个对角线的长度，输出菱形面积。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。


#include<stdio.h>
int main()
{
    double a, b;
    scanf("%lf %lf", &a, &b);
    printf("%.2lf", 1.0 / 2.0 * a * b);
    return 0;
}


//MT1047
//梯形
//输入梯形的两个底的长度和高，输出梯形面积。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。


#include<stdio.h>
int main()
{
    double a, b, h;
    scanf("%lf %lf %lf", &a, &b, &h);
    printf("%.2lf", (a + b) * h / 2.0);
    return 0;
}

//MT1048
//扇形面积
//输入扇形的半径r和圆心角度数n°，输出扇形面积。不考虑非法输入。(PI = 3.1415926)
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型

#include<stdio.h>
#define PI 3.1415926
int main()
{
    double r, n;
    scanf("%lf %lf", &r, &n);
    printf("%lf\n", n / 360 * PI * r * r);
    return 0;
}

//MT1049
//三角形坐标
//输入三角形三个顶点A，B，C的坐标（x, y），根据公式计算并输出三角形面积。
//S = 1 / 2 * | x1y2 + x2y3 + x3y1 - x1y3 - x2y1 - x3y2 |
//
//格式
//输入格式：
//依次输入三个顶点A，B，C的坐标（x, y），整型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。


#include<stdio.h>
int main()
{
    int x1, y1, x2, y2, x3, y3;
    double S;
    scanf("%d %d %d %d %d %d", &x1, &y1, &x2, &y2, &x3, &y3);
    if (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2 >= 0)
    {
        S = 1.0 / 2.0 * (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2);
    }
    else
    {
        S = -1.0 / 2.0 * (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2);
    }
    printf("%.2lf", S);
    return 0;
}

//MT1050
//空间三角形
//输入在三维空间的三角形三个顶点A，B，C的坐标（x, y, z），计算并输出三角形面积。不考虑不能构成三角形的特殊情况。
//
//格式
//输入格式：
//依次输入三个顶点A，B，C的坐标（x, y, z），整型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。


#include<stdio.h>
#include<math.h>
int main()
{
    int x1, y1, z1, x2, y2, z2, x3, y3, z3, a, b, c;
    double S, A, B, C, P;
    scanf("%d %d %d %d %d %d %d %d %d %d", &x1, &y1, &z1, &x2, &y2, &z2, &x3, &y3, &z3);
    a = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2);
    b = (x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2) + (z3 - z2) * (z3 - z2);
    c = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3) + (z1 - z3) * (z1 - z3);
    A = sqrt(a);
    B = sqrt(b);
    C = sqrt(c);
    P = (A + B + C) / 2.0;
    S = sqrt(P * (P - A) * (P - B) * (P - C));
    printf("%.2lf", S);
    return 0;
}


//MT1051
//四边形坐标
//输入四边4个顶点A，B，C，D的坐标（x, y），计算并输出四边形面积。
//
//格式
//输入格式：
//依次输入4个顶点A，B，C，D的坐标（x, y），四边形一定是凸四边形，整型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。

// #include<stdio.h>
// int main() 
// {
//     int x1, y1, x2, y2, x3, y3, x4, y4, X1, X2;
//     double S;
//     scanf("%d %d %d %d %d %d %d %d", &x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
//     X1 = x1*y2+x2*y3+x3*y1-x1*y3-x2*y1-x3*y2;
//     X2 = x1*y4+x4*y3+x3*y1-x1*y3-x4*y1-x3*y4;
//     if (X1 >= 0 && X2 >= 0)
//     {
//         S=1.0/2.0*(X1+X2);
//     }
//     else
//     {
//         S=-1.0/2.0*(X1+X2);
//     }
//     printf("%.2lf", S);
//     return 0; 
// }

//#include<stdio.h>
//int main()
//{
//    int x1, y1, x2, y2, x3, y3, x4, y4;
//    double S;
//    scanf("%d %d %d %d %d %d %d %d", &x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
//    if (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2 >= 0)
//    {
//        S = 1.0 / 2.0 * (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2);
//    }
//    else
//    {
//        S = -1.0 / 2.0 * (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2);
//    }
//    if (x2 * y3 + x3 * y4 + x4 * y2 - x2 * y4 - x3 * y2 - x4 * y3 >= 0)
//    {
//        S = 1.0 / 2.0 * (x2 * y3 + x3 * y4 + x4 * y2 - x2 * y4 - x3 * y2 - x4 * y3) + S;
//    }
//    else
//    {
//        S = -1.0 / 2.0 * (x2 * y3 + x3 * y4 + x4 * y2 - x2 * y4 - x3 * y2 - x4 * y3) + S;
//    }
//    printf("%.2lf", S);
//    return 0;
//}

#include<stdio.h>
int main()
{
    int x1, y1, x2, y2, x3, y3, x4, y4;
    double S = 0;
    scanf("%d %d %d %d %d %d %d %d", &x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);

    if (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2 >= 0)
    {
        S += 1.0 / 2.0 * (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2);
    }
    else
    {
        S += (-1.0 / 2.0 * (x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2));
    }

    if (x2 * y3 + x3 * y4 + x4 * y2 - x2 * y4 - x3 * y2 - x4 * y3 >= 0)
    {
        S += 1.0 / 2.0 * (x2 * y3 + x3 * y4 + x4 * y2 - x2 * y4 - x3 * y2 - x4 * y3);
    }
    else
    {
        S += (-1.0 / 2.0 * (x2 * y3 + x3 * y4 + x4 * y2 - x2 * y4 - x3 * y2 - x4 * y3));
    }

    if (x2 * y4 + x4 * y1 + x1 * y2 - x2 * y1 - x4 * y2 - x1 * y4 >= 0)
    {
        S += 1.0 / 2.0 * (x2 * y4 + x4 * y1 + x1 * y2 - x2 * y1 - x4 * y2 - x1 * y4);
    }
    else
    {
        S += (-1.0 / 2.0 * (x2 * y4 + x4 * y1 + x1 * y2 - x2 * y1 - x4 * y2 - x1 * y4));
    }

    if (x1 * y4 + x4 * y3 + x3 * y1 - x1 * y3 - x4 * y1 - x3 * y4 >= 0)
    {
        S += 1.0 / 2.0 * (x1 * y4 + x4 * y3 + x3 * y1 - x1 * y3 - x4 * y1 - x3 * y4);
    }
    else
    {
        S += (-1.0 / 2.0 * (x1 * y4 + x4 * y3 + x3 * y1 - x1 * y3 - x4 * y1 - x3 * y4));
    }
    printf("%.2lf", S / 2);
    return 0;
}

//MT1052
//直角坐标到极坐标的转换
//请编写一个简单程序，实现直角坐标（x，y）到极坐标(r, θ)的转换。数学中，极坐标系是一个二维坐标系，其中平面上的每个点由一个夹角和一段相对中心点——极点（相当于我们较为熟知的直角坐标系中的原点）的距离来表示。PI = 3.1415926

#include<stdio.h>
#include<math.h>
#define PI 3.1415926
int main()
{
    double x, y, r, o;
    scanf("%lf %lf", &x, &y);
    r = sqrt(x * x + y * y);
    o = atan2(y, x) * 180.0 / PI;
    printf("%.1lf %.1lf", r, o);
    return 0;
}

//MT1053
//极坐标到直角坐标的转换
//请编写一个简单程序，实现极坐标(r, θ)到直角坐标（x，y）的转换。数学中，极坐标系是一个二维坐标系，其中平面上的每个点由一个夹角和一段相对中心点——极点（相当于我们较为熟知的直角坐标系中的原点）的距离来表示。PI = 3.1415926
//
//其中：
//x = r × cos(θ)
//y = r × sin(θ)
//
//格式
//输入格式：
//输入实型，空格分隔
//
//输出格式：
//输出实型，逗号分隔，保留2位小数

#include<stdio.h>
#include<math.h>
#define PI 3.1415926
int main()
{
    double r, o, x, y;
    scanf("%lf %lf", &r, &o);
    x = r * cos(o * PI / 180.0);
    y = r * sin(o * PI / 180.0);
    printf("%.2lf,%.2lf", x, y);
    return 0;
}

//MT1054
//弓形弦长
//假定弓形弦长为C, 半径为R，弦高为H，输入R和H，输出弓形弦长C。计算公式如下：
//�
//=
//2
//∗
//�
//∗
//(
//    2
//    ∗
//    �
//    −
//    �
//)
//C = 2∗
//H∗(2∗R−H)
//​
//
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
#include<math.h>
int main()
{
    double R, H, C;
    scanf("%lf %lf", &R, &H);
    C = 2 * sqrt(H * (2 * R - H));
    printf("%.2lf", C);
    return 0;
}

//MT1055
//弓形半径
//假定弓形弦长为C, 半径为R，弦高为H，输入C和H，按公式R = (C * C + 4 * H * H) / 8H输出弓形半径R。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
int main()
{
    double C, H, R;
    scanf("%lf %lf", &C, &H);
    R = (C * C + 4 * H * H) / (8 * H);
    printf("%.2lf\n", R);
    return 0;
}

//MT1056
//弓形弧长
//假定弓形弧长为L, 半径为R，圆心角为A，输入R和A，按公式L = 0.01745R * A计算并输出弓形弧长L。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
int main()
{
    double L, R, A;
    scanf("%lf %lf", &R, &A);
    L = 0.01745 * R * A;
    printf("%.2lf", L);
    return 0;
}

//MT1057
//弓形圆心角
//假定弓形弧长为L, 半径为R，圆心角为A，输入R和L，按公式A = 57.296L / R计算并输出弓形圆心角A。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
int main()
{
    double A, R, L;
    scanf("%lf %lf", &R, &L);
    A = 57.296 * L / R;
    printf("%.2lf", A);
    return 0;
}

//MT1058
//弓形弦高
//假定弓形弦长为C, 半径为R，弦高为H，输入R和C，按公式计算并输出弓形弦高H。
//
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
#include<math.h>
int main()
{
    double H, R, C;
    scanf("%lf %lf", &R, &C);
    H = R - 1.0 / 2.0 * sqrt(4 * R * R - C * C);
    printf("%.2lf\n", H);
    return 0;
}

//MT1059
//弓形面积
//假定弓形弦长为C, 半径为R，弦高为H，弧长为L, 输入R、C、H和L，按公式计算并输出弓形面积F。
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留3位小数。

#include<stdio.h>
int main()
{
    double F, R, C, H, L;
    scanf("%lf %lf %lf %lf", &R, &C, &H, &L);
    F = 1.0 / 2.0 * (R * L - C * (R - H));
    printf("%.3lf", F);
    return 0;
}

//MT1060
//圆锥的表面积
//请编写一个简单程序，输入半径和高度，计算输出圆锥的表面积。（PI是3.1415926）
//
//计算公式为：
//格式
//输入格式：
//double型，空格分隔
//
//输出格式：
//输出圆锥的表面积，保留2位小数

#include<stdio.h>
#include<math.h>
#define PI 3.1415926
int main()
{
    double Area, r, h;
    scanf("%lf %lf", &r, &h);
    Area = PI * r * (r + sqrt(r * r + h * h));
    printf("Surface area=%.2lf", Area);
    return 0;
}

//MT1061
//圆锥体的体积
//请编写一个简单程序，输入圆锥体的半径和高，输出圆锥体的体积。不考虑非法输入。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型

#include<stdio.h>
#define PI 3.1415926
int main()
{
    double r, h;
    scanf("%lf %lf", &r, &h);
    printf("%lf", 1.0 / 3.0 * h * (PI * r * r));
    return 0;
}

//MT1062
//圆锥体表面积
//请编写一个简单程序，输入圆锥体的半径和高，输出圆锥体表面积。不考虑非法输入。(PI = 3.1415926)
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型

#include<stdio.h>
#include<math.h>
#define PI 3.1415926
int main()
{
    double r, h;
    scanf("%lf %lf", &r, &h);
    printf("%lf", PI * r * r + PI * r * sqrt(r * r + h * h));
    return 0;
}


//MT1063
//立方体的体积
//输入立方体边长，输出立方体的体积。不考虑非法输入。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出实型

#include<stdio.h>
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%lf", x * x * x);
    return 0;
}

//MT1064
//立方体的表面积
//输入立方体边长，输出立方体的表面积。不考虑非法输入。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出实型

#include<stdio.h>
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%lf", x * x * 6);
    return 0;
}

//MT1065
//长方体的表面积
//输入长方体边长宽高，输出长方体的表面积。不考虑非法输入。
//
//格式
//输入格式：
//输入实型，空格分隔。
//
//输出格式：
//输出实型，保留6位小数

#include<stdio.h>
int main()
{
    double x, y, z;
    scanf("%lf %lf %lf", &x, &y, &z);
    printf("%.6lf", 2 * (x * y + y * z + z * x));
    return 0;
}

//MT1066
//射线
//在一条直线上点上N(N >= 1)个点可以把这条直线分成多少条射线？N从键盘输入。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    printf("%d", 2 * N);
    return 0;
}

//MT1067
//线段
//有一条直线，线上有n个点（n >= 2），请问这条直线会被分隔成多少个线段。n从键盘输入。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int N, num = 0;
    scanf("%d", &N);
    for (int i = 1; i < N; i++)
    {
        num += i;
    }
    printf("%d", num);
    return 0;
}

//MT1068
//直线切平面
//直线切平面，输入直线条数N，问最多把平面分成几块。比如一条直线可以把一个平面切割成2块。可以使用公式S = n * (n + 1) / 2 + 1 。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    printf("%d", N * (N + 1) / 2 + 1);
    return 0;
}

//MT1069
//圆切平面
//n个圆最多把平面分成几部分？输入圆的数量N，问最多把平面分成几块。比如一个圆以把一个平面切割成2块。 不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    double N;
    scanf("%lf", &N);
    printf("%.0lf", N * N - N + 2);
    return 0;
}


//MT1070
//随机数的游戏
//小码哥在1到10之间随机选择了一个数字N，然后把所选数字加倍，之后加上一个偶数K，然后把所得的数字除以2，再把得的商与原始数字N相减，输出他们的差。不考虑负数，0或者其他特殊情况。比如输入N和K分别为8和2，那么8 * 2 = 16，16 + 2 = 18，18 / 2 = 9，9 - 8 = 1 ，那么应该输出1。
//
//格式
//输入格式：
//输入为整型数字N和K，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int N, K;
    scanf("%d %d", &N, &K);
    printf("%d", (2 * N + K) / 2 - N);
    return 0;
}

//MT1071
//计算表达式的值
//请编写一个简单程序，计算45除以2再加上43.41592，然后减去36除以7的商，输出运算结果。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出实型

#include<stdio.h>
int main()
{
    printf("%lf", 45.0 / 2.0 + 43.41592 - 36.0 / 7.0);
    return 0;
}

//MT1072
//分数运算
//输入两个分数，对他们进行加减乘除运算，输出结果。不考虑分母为0等特殊情况。
//
//格式
//输入格式：
//输入整型，如样例所示。
//
//输出格式：
//输出计算结果实型，如样例所示。


#include<stdio.h>
int main()
{
    double x, y, a, b, z1, z2;
    scanf("%lf/%lf %lf/%lf", &x, &y, &a, &b);
    z1 = x / y;
    z2 = a / b;
    printf("%.0lf/%.0lf + %.0lf/%.0lf=%lf\n", x, y, a, b, z1 + z2);
    printf("%.0lf/%.0lf - %.0lf/%.0lf=%lf\n", x, y, a, b, z1 - z2);
    printf("%.0lf/%.0lf * %.0lf/%.0lf=%lf\n", x, y, a, b, z1 * z2);
    printf("%.0lf/%.0lf / %.0lf/%.0lf=%lf\n", x, y, a, b, z1 / z2);
    return 0;
}

//MT1073
//时刻求和
//输入正整数N和M，空格分隔。把他们看作在12小时制的时刻（小时）求和并输出，输出最小列宽为3列。
//
//格式
//输入格式：
//输入正整数N和M，空格分隔。
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, M;
    scanf("%d %d", &N, &M);
    if (N + M >= 12)
    {
        printf("%3d", N + M - 12);
    }
    else
    {
        printf("%3d", N + M);
    }
    return 0;
}

//MT1074
//平方根和对数值
//请编写一个简单程序，计算求给定数的平方根、2个对数值（ln, lg）。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出平方根、对数值，空格分隔，保留两位小数

#include<stdio.h>
#include<math.h>
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%.2lf %.2lf %.2lf", sqrt(x), log(x), log10(x));
    return 0;
}

//MT1075
//平方根X
//输入正整数N, 求N的平方根X。如果N不是一个完美的平方，输出floor(X) 。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出整型

#include<stdio.h>
#include<math.h>
int main()
{
    int N;
    scanf("%d", &N);
    int n = (double)sqrt(N);
    printf("%d\n", n);
    return 0;
}

//MT1076
//三维空间两点
//输入三维空间两点坐标（x, y, z），计算两点之间的距离并输出。
//
//格式
//输入格式：
//输入实型坐标（x, y, z），空格分隔。每行以一个点。
//
//输出格式：
//输出实型，保留2位小数。


#include<stdio.h>
int main()
{
    double x1, x2, y1, y2, z1, z2;
    scanf("%lf %lf %lf", &x1, &y1, &z1);
    scanf("%lf %lf %lf", &x2, &y2, &z2);
    printf("%.2lf\n", sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2) + pow(z2 - z1, 2)));
    return 0;
}


//MT1077
//幸运数
//假定幸运数是只包含4或7的正整数，如7、47。判断一个正整数n是不是一个幸运数。是则输出YES，否则输出NO。不考虑负数，0或者其他特殊情况。不考虑溢出或者超出整型范围的情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//是幸运数则输出YES, 否则输出NO

#include<stdio.h>
int main()
{
    int x, flag;
    scanf("%d", &x);
    while (x)
    {
        if (x % 10 == 4 || x % 10 == 7)
        {
            flag = 1;
            x /= 10;
        }
        else
        {
            flag = 0;
            break;
        }
    }
    if (flag == 1)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1078 整除幸运数
//（1）题目
//假定幸运数是只包含4或7的正整数，如7、47。判断一个正整数n是否能被一个幸运数整除。是则输出YES，否则输出NO。不考虑负数，0或者其他特殊情况。不考虑溢出或者超出整型范围的情况。
//
//格式
//
//输入格式 :
//输入为整型
//
//输出格式 :
//能被一个幸运数整除则输出YES, 否则输出NO
//1
//2
//3
//4
//5
//样例1
//
//输入格式 :
//47
//
//输出格式 :
//    YES
//    1
//    2
//    3
//    4
//    5
//    （2）参考代码

#include<stdio.h>
    int main()
{
    int n, temp, flag;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        if (n % i == 0)
        {
            temp = i;
            flag = 1;
            while (temp)
            {
                if (temp % 10 != 4 && temp % 10 != 7)
                {
                    flag = 0;
                    break;
                }
                temp /= 10;
            }
        }
        if (flag == 1)
        {
            printf("YES");
            return 0;
        }
    }
    printf("NO");
    return 0;
}



//MT1079
//floor函数
//给定一个正整数n，求满足floor（n / x） = y的x和y(x和y是正整数)。比如输入5，则(x, y)的组合可以有:(1, 5), (2, 2), (3, 1), (4, 1), (5, 1)。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型，空格分隔，每组一行。前一个数为x，后面一个为y。输出按照x从小到大的次序输出。


#include<stdio.h>
int main()
{
    int n, y = 0;
    scanf("%d", &n);
    for (int x = 1; x <= n; x++)
    {
        y = n / x;
        printf("%d %d\n", x, y);
    }
    return 0;
}

//MT1080
//乘积之和
//给定一个正整数n，求满足floor（n / x） = y的x和y的乘积之和(x和y是正整数)。比如输入5，则(x, y)的组合可以有:(1, 5), (2, 2), (3, 1), (4, 1), (5, 1)，那么， 1 * 5 + 2 * 2 + 3 * 1 + 4 * 1 + 5 * 1 = 5 + 4 + 3 + 4 + 5 = 21。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int n, y = 0, sum = 0;
    scanf("%d", &n);
    for (int x = 1; x <= n; x++)
    {
        y = n / x;
        sum += x * y;
    }
    printf("%d\n", sum);
    return 0;
}


//MT1081
//x + y的和
//给定一个正整数n，求满足floor（n / x） = y的x和y的和。不考虑负数，0或者其他特殊情况。比如输入5，则(x, y)的组合可以有:(1, 5), (2, 2), (3, 1), (4, 1), (5, 1)，那么， 1 + 5 + 2 + 2 + 3 + 1 + 4 + 1 + 5 + 1 = 6 + 4 + 4 + 5 + 6 = 25。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n, x, y, sum = 0;
    scanf("%d", &n);
    for (x = 1; x <= n; x++)
    {
        y = n / x;
        sum += x + y;
    }
    printf("%d\n", sum);
    return 0;
}


//MT1082
//x - y的和
//给定一个正整数n，求满足floor（n / x） = y的x和y的差之和。x，y不考虑负数，0或者其他特殊情况。比如输入5，则(x, y)的组合可以有：(1, 5), (2, 2), (3, 1), (4, 1), (5, 1)，那么， 1 - 5 + 2 - 2 + 3 - 1 + 4 - 1 + 5 - 1 = -4 + 0 + 2 + 3 + 4 = 5。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int n, x, y, sum = 0;
    scanf("%d", &n);
    for (x = 1; x <= n; x++)
    {
        y = n / x;
        sum += x - y;
    }
    printf("%d\n", sum);
    return 0;
}

//MT1083
//向下取整
//输入正整数N，求N的立方根。向下取整后输出，输出最小列宽为3列。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出整型


#include<stdio.h>
#include<math.h>
int main()
{
    double N;
    scanf("%lf", &N);
    printf("%3d\n", (int)pow(N, 1.0 / 3.0));
    return 0;
}

//MT1084
//K次方根
//输入正整数N和K。找出整数M，使得M的K次方根的整数部分是N。输出这样的M有多少个。比如N = 3, K = 2，则9, 10, 11, 12, 13, 14, 15 的平方根都是3。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型

#include<stdio.h>
#include<math.h>
int main()
{
    int N, K, min_M, max_M;
    scanf("%d %d", &N, &K);
    min_M = pow(N, K);
    max_M = pow(N + 1, K);
    printf("%d\n", max_M - min_M);
    return 0;
}


//MT1085
//分期付款
//请编写一个简单程序，使用以下公式计算每月分期付款：
//
//其中：
//p = 本金
//r = 每月利率
//n = 分期付款多少个月
//
//如果年利率为R % ，则使用以下公式计算月利率：
//Rate(r) = R / (12 * 100)

#include<stdio.h>
#include<math.h>
int main()
{
    double p, r, n, EMI, R;
    scanf("%lf %lf %lf", &p, &R, &n);
    r = R / (12 * 100);
    EMI = p * r * pow(1 + r, n) / (pow(1 + r, n) - 1);
    printf("%.1lf", EMI);
    return 0;
}

//MT1086
//公里转换为米
//请编写一个简单程序，实现将公里（km）转换为米（m）的转换。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出实型， 保留2位小数

#include<stdio.h>
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%.2lf公里=%.2lf米", x, 1000 * x);
    return 0;
}


//MT1087
//温度转换
//请编写一个简单程序，实现以摄氏度为单位的温度转换为华氏度，不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出实型，保留2位小数，如样例所示。


#include<stdio.h>
int main()
{
    double C;
    scanf("%lf", &C);
    printf("%.2lf C=%.2lf F", C, 9 * C / 5 + 32);
    return 0;
}

//MT1088
//温度对照
//输出华氏温度F（ - 50 <= F < 200）和摄氏温度C对照表，其计算公式为C = 9(F−32) / 5。不考虑非法输入等特殊情况。
//
//格式
//输入格式：
//输入华氏温度F为整型
//
//输出格式：
//输出摄氏温度C为实型


#include<stdio.h>
int main()
{
    double F;
    scanf("%lf", &F);
    printf("%lf", 9 * (F - 32) / 5);
    return 0;
}

//MT1089

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    printf("%d", N / 2 + 1);
    return 0;
}


//MT1090
//卡罗尔序列
//卡罗尔数是其值满足4n–2（n + 1）–1的整数（n为正整数）。由卡罗尔数组成的序列叫卡罗尔序列： - 1, 1, 3, 5, 7…输入正整数N，编写函数，输出第N个卡罗尔数。
//
//格式
//输入格式：
//输入正整数N(< 99999)
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    printf("%d", 4 * N - 2 * (N + 1) - 1);
    return 0;
}

//MT1091
//合并II
//输入两个两位数的正整数a、b，编写程序将a、b合并形成一个整数放在c中，合并的方式是：将a数的十位和个位数依次放在c数的百位和个位上，b数的十位和个位数依次放在c数的十位和千位上，输出c的结果。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int a, b, z1, z2, z3, z4, c;
    scanf("%d %d", &a, &b);
    z1 = a / 10;
    z2 = a % 10;
    z3 = b / 10;
    z4 = b % 10;
    c = z1 * 100 + z2 * 1 + z3 * 10 + z4 * 1000;
    printf("%d\n", c);
    return 0;
}

//MT1092
//非常大的N
//编写程序求11 / 2 - 21 / 2 + 31 / 2 - 41 / 2 + 51 / 2…… + N1 / 2。
//
//格式
//输入格式：
//输入为正整数
//
//输出格式：
//输出为浮点型（保留六位小数）。

#include<stdio.h>
#include<math.h>
int main()
{
    int N, i, temp = 1;
    double sum = 0;
    scanf("%d", &N);
    for (i = 1; i <= N; i++)
    {
        sum += temp * pow(i, 1.0 / 2.0);
        temp *= -1;
    }
    printf("%.6lf", sum);
    return 0;
}

//MT1093
//序列
//有一个序列1, 3, 6, 10, 15, 21 ….，请找出它的规律，输入整数N，输出第N项。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int N, i = 1, j = 1;
    scanf("%d", &N);
    if (N % 2 == 0)
    {
        printf("%d", N / 2 * (N + 1));
    }
    else
    {
        printf("%d", (N + 1) / 2 * N);
    }
    return 0;
}


//MT1094
//AP数列
//输入AP数列(正整数)的前两项A1、A2和n。输出序列的第n项。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int A1, A2, n, d;
    scanf("%d %d %d", &A1, &A2, &n);
    d = A2 - A1;
    printf("%d", A1 + (n - 1) * d);
    return 0;
}


//MT1095
//GP数列
//输入GP数列(正整数)的前两项A1、A2和n。输出序列的第n项。 不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型


#include<stdio.h>
#include<math.h>
int main()
{
    int A1, A2, n;
    double q;
    scanf("%d %d %d", &A1, &A2, &n);
    q = A2 / A1;
    printf("%d", (int)(A1 * pow(q, n - 1)));
    return 0;
}


//MT1096
//三角形斜边
//假定直角三角形的斜边是固定长度的，输入三角形的最大可能面积，输出斜边的长度。比如最大面积为25的直角三角形，斜边的长度是10。不考虑负数，0或者其他特殊情况。不考虑溢出或者超出数据范围的情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
#include<math.h>
int main()
{
    double s;
    scanf("%lf", &s);
    printf("%d\n", (int)sqrt(4 * s));
    //printf("%d\n", sqrt(4 * s));
    //输出结果为1
    return 0;
}

//MT1097
//小码哥的生日
//小码哥过生日，妈妈给她买了一个很大的蛋糕，小码哥开始给朋友们分蛋糕，如果切n刀，最多可以分给多少小朋友呢？每个朋友一块蛋糕。不考虑负数，0或者其他特殊情况。n从键盘输入。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    printf("%d", N * (N + 1) / 2 + 1);
    return 0;
}


//MT1098
//完全平方数
//输入一个正整数n，检查它是否为完全平方数。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为YES或者NO


#include<stdio.h>
int main()
{
    int n, i;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        if (i * i == n)
        {
            printf("YES");
            return 0;
        }
    }
    printf("NO");
    return 0;
}

//MT1099
//个人所得税
//将个人所得税算法定义为宏。个人所得税计算公式为：应纳税所得额s×税率－速算扣除数。不考虑不合理的输入或是溢出等特殊情况。税率如下表：
//
//应纳税所得额
//
//税率%
//
//速算扣除数
//
//s <= 500
//
//5
//
//0
//
//500 < s <= 2000
//
//10
//
//25
//
//2000 < s <= 5000
//
//15
//
//125
//
//5000 < s <= 20000
//
//20
//
//375
//
//20000 < s <= 40000
//
//25
//
//1375
//
//40000 < s <= 60000
//
//30
//
//3375
//
//60000 < s <= 80000
//
//35
//
//6375
//
//80000 < s <= 100000
//
//40
//
//10375
//
//100000 < s
//
//45
//
//15375
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型


#include<stdio.h>
#define tax(s, rate, k) ((s)*(rate)-(k))
int main()
{
    int s, k;
    double rate;
    scanf("%d", &s);
    if (s <= 500)
    {
        rate = 0.05;
        k = 0;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (500 < s && s <= 2000)
    {
        rate = 0.10;
        k = 25;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (2000 < s && s <= 5000)
    {
        rate = 0.15;
        k = 125;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (5000 < s && s <= 20000)
    {
        rate = 0.20;
        k = 375;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (20000 < s && s <= 40000)
    {
        rate = 0.25;
        k = 1375;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (40000 < s && s <= 60000)
    {
        rate = 0.30;
        k = 3375;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (60000 < s && s <= 80000)
    {
        rate = 0.35;
        k = 6375;
        printf("%d", (int)tax(s, rate, k));
    }
    else if (80000 < s && s <= 100000)
    {
        rate = 0.40;
        k = 10375;
        printf("%d", (int)tax(s, rate, k));
    }
    else
    {
        rate = 0.45;
        k = 15375;
        printf("%d", (int)tax(s, rate, k));
    }
    return 0;
}


//MT1100
//带参数的宏
//请编写一个简单程序，把f(x) = (x * x)定义成带参数的宏，计算f(9) / f(6)并输出结果。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为实型


#include<stdio.h>
#define f(x) ((x)*(x))
int main()
{
    printf("%lf\n", f(9.0) / f(6.0));
    return 0;
}



//MT1101
//带参数的宏II
//请编写一个简单程序，把f(x) = x * (x - 1)定义成带参数的宏，从键盘输入a，b，将a + b的和作为宏实参计算并输出结果。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//输出为实型


#include<stdio.h>
#define f(x) ((x)*((x)-1))
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%lf\n", (double)f(a + b));
    return 0;
}


//MT1102
//长方体
//将长方体体积计算公式定义为宏。在主函数中输入长方体长、宽、高求体积。不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入为实型（正数），空格分隔。
//
//输出格式：
//输出为实型


#include<stdio.h>
#define VOLUME(x, y, z) ((x)*(y)*(z))
int main()
{
    double x, y, z;
    scanf("%lf %lf %lf", &x, &y, &z);
    printf("%lf\n", VOLUME(x, y, z));
    return 0;
}

//MT1103
//球体积
//将球体积计算公式定义为宏。在主函数中输入半径求体积。
//
//格式
//输入格式：
//输入为实型
//
//输出格式：
//输出为实型


#include<stdio.h>
#define PI 3.14159
#define VOLUME(r) (4.0/3.0*PI*(r)*(r)*(r))
int main()
{
    double r;
    scanf("%lf", &r);
    printf("%lf\n", VOLUME(r));
    return 0;
}

//MT1104
//三角形
//三角形三边长a、b、c，用宏表示面积公式
//
//s(s−a)(s−b)(s−c)
//​
//。在主函数中输入数据求三角形的面积。不能构成三角形输出 - 1。
//
//格式
//输入格式：
//输入为实型
//
//输出格式：
//输出为实型

#include<stdio.h>
#include <math.h>
#define Area(a, b ,c, s) (sqrt((s)*((s)-(a))*((s)-(b))*((s)-(c))))
int main()
{
    double a, b, c, s;
    scanf("%lf %lf %lf", &a, &b, &c);
    s = (a + b + c) / 2;
    if (a + b > c && a + c > b && b + c > a)
    {
        printf("%lf", Area(a, b, c, s));
    }
    else
    {
        printf("%d", -1);
    }
    return 0;
}


//MT1105
//英寸英尺英里
//定义关于长度的宏，英寸 / 厘米、英尺 / 米、英里 / 公里，计算英制与公制单位转换，在主函数中输入数据输出计算结果。假定1英寸 = 2.54厘米、1英尺 = 0.31米、1英里 = 1.61公里。
//
//格式
//输入格式：
//输入英寸、英尺、英里为实型，空格分隔。
//
//输出格式：
//输出厘米、米、公里为实型，空格分隔。保留2位小数。


#include<stdio.h>
#define INCH_cm(x) ((x) * 2.54)
#define FEET_m(x) ((x) * 0.31)
#define MILE_km(x) ((x) * 1.61)
int main()
{
    double a, b, c;
    scanf("%lf %lf %lf", &a, &b, &c);
    printf("%.2lf %.2lf %.2lf\n", INCH_cm(a), FEET_m(b), MILE_km(c));
    return 0;
}

//MT1106
//盎司磅
//定义关于重量的宏，盎司 / 克、磅 / 公斤，计算美制单位与公制转换，在主函数中输入数据输出计算结果。
//
//格式
//输入格式：
//输入盎司、磅为实型，空格分隔
//
//输出格式：
//输出克、公斤实型，空格分隔。保留2位小数。


#include<stdio.h>
#define oz_g(oz) ((oz)*28.35)
#define lb_kg(lb) ((lb)*0.45)
int main()
{
    double oz, lb;
    scanf("%lf %lf", &oz, &lb);
    printf("%.2lf %.2lf", oz_g(oz), lb_kg(lb));
    return 0;
}

//MT1107
//加仑 / 升
//定义关于容量的宏，加仑 / 升，计算单位转换，在主函数中输入数据输出计算结果。
//
//格式
//输入格式：
//输入加仑为实型。
//
//输出格式：
//输出升为实型，保留2位小数。


#include<stdio.h>
#define GALLON_LITRE(x) ((x) * 3.79)
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%.2lf\n", GALLON_LITRE(x));
    return 0;
}

//MT1108
//保留小数
//将一个浮点型K数保留n(1≤n≤5)位小数（四舍五入）的算法定义为宏。在主函数中输入数据输出计算结果。
//
//格式
//输入格式：
//输入k为实型，n为整数，空格分隔。
//
//输出格式：
//输出为实型

#include<stdio.h>
#define ROUND_UP(k, n) printf("%.*lf", (n), (k))
int main()
{
    double k;
    int n;
    scanf("%lf %d", &k, &n);
    ROUND_UP(k, n);
    return 0;
}

//MT1109
//和10相比
//请编写一个简单程序，输入一个整数，和10比较，输出比较结果
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出…大于或者等于或者小于10



#include<stdio.h>
int main()
{
    int x;
    scanf("%d", &x);
    if (x > 10)
    {
        printf("%d大于10", x);
    }
    else if (x < 10)
    {
        printf("%d小于10", x);
    }
    else
    {
        printf("%d等于10", x);
    }
    return 0;
}



//MT1110
//最小值
//输入a, b两个整数，输出他们之间的最小值
//
//格式
//输入格式：
//输入2个整数用空格分隔
//
//输出格式：
//输出为整型



#include<stdio.h>
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    if (a > b)
    {
        printf("%d", b);
    }
    else
    {
        printf("%d", a);
    }
    return 0;
}

//MT1111
//最大值
//输入a, b两个整数，输出他们之间的最大值
//
//格式
//输入格式：
//输入2个整数用空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    if (a > b)
    {
        printf("%d", a);
    }
    else
    {
        printf("%d", b);
    }
    return 0;
}

//MT1112
//中庸之道
//请编写一个简单程序，输入3个整数，比较他们的大小，输出中间的那个数
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    if ((a > b && b > c) || (a < b && b < c))
    {
        printf("%d", b);
    }
    else if ((c > a && a > b) || (c < a && a < b))
    {
        printf("%d", a);
    }
    else
    {
        printf("%d", c);
    }
    return 0;
}

//MT1113
//三人同行
//三人同行，输入他们的年龄，输出最年长者的年龄
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型


#include<stdio.h>
#define max(x, y) ((x)>(y)?(x):(y))
int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    printf("%d", max(max(a, b), max(a, c)));
    return 0;
}


//MT1114
//偶数还是奇数
//请编写一个简单程序，检查一个正整数是偶数还是奇数，如果是偶数输出Y，否则输出N。（不考虑0）
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出Y或者N



#include<stdio.h>
int main()
{
    int x;
    scanf("%d", &x);
    if (x % 2 == 0)
    {
        printf("Y");
    }
    else
    {
        printf("N");
    }
    return 0;
}


//MT1115
//小于m的偶数
//判断n是否为小于m的偶数，不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型n、m，空格分隔
//
//输出格式：
//是则输出YES否则输出NO


#include<stdio.h>
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    if (n < m && n % 2 == 0)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}



//MT1116
//正整数
//判断n是否为两位数的正整数
//
//格式
//输入格式：
//输入为整型n
//
//输出格式：
//是则输出YES否则输出NO



#include<stdio.h>
int main()
{
    int x;
    scanf("%d", &x);
    if ((x >= 10) && (x <= 99))
    {
        if (x >= 0)
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1117
//两个负数
//判断x、y、z中是否有两个负数。
//
//格式
//输入格式：
//输入为整型x、y、z，空格分隔
//
//输出格式：
//是则输出YES否则输出NO


#include<stdio.h>
int main()
{
    int x, y, z;
    scanf("%d %d %d", &x, &y, &z);
    if ((x < 0 && y < 0) || (x < 0 && z < 0) || (z < 0 && y < 0))
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1118
//等差数列
//判断a、b、c是否为一个等差数列中的连续三项。
//
//格式
//输入格式：
//输入为整型a、b、c，空格分隔
//
//输出格式：
//是则输出YES否则输出NO


#include<stdio.h>
int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    if ((c - b) == (b - a))
    {
        printf("YES\n");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1119
//大小写的转换
//请编写一个简单程序，实现输入字符大小写的转换。其他非法输入（非字母的输入）则原样输出。
//
//格式
//输入格式：
//输入字符型
//
//输出格式：
//输出字符型



#include<stdio.h>
#include<ctype.h>
int main()
{
    char str;
    scanf("%c", &str);
    if (isalpha(str))
    {
        if (str >= 65 && str <= 90)
        {
            str += 32;
            printf("%c", str);
        }
        else
        {
            str -= 32;
            printf("%c", str);
        }
    }
    else
    {
        printf("%c", str);
    }
    return 0;
}

//MT1120
//老师的评语
//请编写一个简单程序，输入学生成绩等级ABCD，输出相应的评语“Excellent”、 “Well done”、“You passed”、“Better luck next time”。 非法输入时候则输出“Invalid grade”
//
//格式
//输入格式：
//输入字符型
//
//输出格式：
//输出字符评语


#include<stdio.h>
int main()
{
    char level;
    scanf("%c", &level);
    if (level == 'A')
    {
        printf("Excellent");
    }
    else if (level == 'B')
    {
        printf("Well done");
    }
    else if (level == 'C')
    {
        printf("You passed");
    }
    else if (level == 'D')
    {
        printf("Better luck next time");
    }
    else
    {
        printf("Invalid grade");
    }
    return 0;
}

//MT1121
//小码哥考完咯
//小码哥考完咯，你是她的老师，请使用switch语句编写一个程序，输出她的分数对应的成绩等级ABCDF。使用以下分级标准：A = 90 - 100，B = 80 - 89，C = 70 - 79，D = 60 - 69，F = 0 - 59。不考虑负数或者其他特殊情况。本题要求使用switch语句。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为字符型


#include<stdio.h>
int main()
{
    int grade;
    scanf("%d", &grade);
    grade = grade / 10;
    switch (grade)
    {
    case 10:
        printf("A");
        break;
    case 9:
        printf("A");
        break;
    case 8:
        printf("B");
        break;
    case 7:
        printf("C");
        break;
    case 6:
        printf("D");
        break;
    default:
        printf("F");
    }
    return 0;
}

//MT1122
//阶梯IF - ELSE
//小码哥考完咯，你是她的老师，请编写一个程序，输出她的分数对应的成绩等级ABCDF。使用以下分级标准：A = 90 - 100，B = 80 - 89，C = 70 - 79，D = 60 - 69，F = 0 - 59不考虑负数或者其他特殊情况。本题要求使用阶梯IF - ELSE语句，不得使用switch。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int x;
    scanf("%d", &x);
    if (x <= 100 && x >= 90)
    {
        printf("A");
    }
    else if (x <= 89 && x >= 80)
    {
        printf("B");
    }
    else if (x <= 79 && x >= 70)
    {
        printf("C");
    }
    else if (x <= 69 && x >= 60)
    {
        printf("D");
    }
    else if (x <= 59 && x >= 0)
    {
        printf("F");
    }
    else
    {
        printf("Error");
    }
    return 0;
}


//MT1123
//元音
//请编写一个简单程序，检查输入字符是否为元音
//
//格式
//输入格式：
//输入字符型
//
//输出格式：
//输出Y或者N

#include<stdio.h>
int main()
{
    char letter;
    scanf("%c", &letter);
    if (letter == 'A' || letter == 'a')
    {
        printf("Y");
    }
    else if (letter == 'B' || letter == 'b')
    {
        printf("Y");
    }
    else if (letter == 'E' || letter == 'e')
    {
        printf("Y");
    }
    else if (letter == 'I' || letter == 'i')
    {
        printf("Y");
    }
    else if (letter == 'O' || letter == 'o')
    {
        printf("Y");
    }
    else if (letter == 'U' || letter == 'u')
    {
        printf("Y");
    }
    else
    {
        printf("N");
    }
    return 0;
}


//MT1124
//罗马数字
//编一个程序，输入一个整数（1~9），输出对应大写罗马数字。不考虑非法的不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出字符串


// 讲您的键盘输入法设置为标准的键盘。

// 按出字母 v 。

// 按出键盘上的您需要的数字。

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n == 1)
    {
        printf("I");
    }
    else if (n == 2)
    {
        printf("II");
    }
    else if (n == 3)
    {
        printf("III");
    }
    else if (n == 4)
    {
        printf("IV");
    }
    else if (n == 5)
    {
        printf("V");
    }
    else if (n == 6)
    {
        printf("VI");
    }
    else if (n == 7)
    {
        printf("VII");
    }
    else if (n == 8)
    {
        printf("VIII");
    }
    else
    {
        printf("IX");
    }
    return 0;
}

//MT1125 几月份


#include<stdio.h>
#include<string.h>
int main()
{
    char a[20];
    gets(a);
    if (strcmp(a, "january") == 0)
    {
        printf("1");
    }
    else if (strcmp(a, "february") == 0)
    {
        printf("2");
    }
    else if (strcmp(a, "march") == 0)
    {
        printf("3");
    }
    else if (strcmp(a, "april") == 0)
    {
        printf("4");
    }
    else if (strcmp(a, "may") == 0)
    {
        printf("5");
    }
    else if (strcmp(a, "june") == 0)
    {
        printf("6");
    }
    else if (strcmp(a, "july") == 0)
    {
        printf("7");
    }
    else if (strcmp(a, "august") == 0)
    {
        printf("8");
    }
    else if (strcmp(a, "september") == 0)
    {
        printf("9");
    }
    else if (strcmp(a, "october") == 0)
    {
        printf("10");
    }
    else if (strcmp(a, "november") == 0)
    {
        printf("11");
    }
    else if (strcmp(a, "december") == 0)
    {
        printf("12");
    }
    return 0;
}



//MT1126

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n == 1)
    {
        printf("shu");
    }
    else if (n == 2)
    {
        printf("niu");
    }
    else if (n == 3)
    {
        printf("hu");
    }
    else if (n == 4)
    {
        printf("tu");
    }
    else if (n == 5)
    {
        printf("long");
    }
    else if (n == 6)
    {
        printf("she");
    }
    else if (n == 7)
    {
        printf("ma");
    }
    else if (n == 8)
    {
        printf("yang");
    }
    else if (n == 9)
    {
        printf("hou");
    }
    else if (n == 10)
    {
        printf("ji");
    }
    else if (n == 11)
    {
        printf("gou");
    }
    else if (n == 12)
    {
        printf("zhu");
    }
    return 0;
}





//MT1127
//小码哥的属相
//输入小码哥的生日年份(1900~2050)，计算输出小码哥的属相生肖(“rat”, “ox”, “tiger”, “rabbit”, “dragon”, “snake”, “horse”, “sheep”, “monkey”, “rooster”, “dog”, “pig”)。不考虑非法输入等特殊情况。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出字符串

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    n = n % 12;
    if (n == 0)
    {
        printf("monkey");
    }
    else if (n == 1)
    {
        printf("rooster");
    }
    else if (n == 2)
    {
        printf("dog");
    }
    else if (n == 3)
    {
        printf("pig");
    }
    else if (n == 4)
    {
        printf("rat");
    }
    else if (n == 5)
    {
        printf("ox");
    }
    else if (n == 6)
    {
        printf("tiger");
    }
    else if (n == 7)
    {
        printf("rabbit");
    }
    else if (n == 8)
    {
        printf("dragon");
    }
    else if (n == 9)
    {
        printf("snake");
    }
    else if (n == 10)
    {
        printf("horse");
    }
    else if (n == 11)
    {
        printf("sheep");
    }
    return 0;
}

//MT1128
//骰子的反面
//小码哥抛出一个六面骰子。每个面上都印有一个数字，数字在1到6之间。输入正面的数字，输出对面的数字。 其他情况输出 - 1。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n == 1)
    {
        printf("6");
    }
    else if (n == 2)
    {
        printf("5");
    }
    else if (n == 3)
    {
        printf("4");
    }
    else if (n == 4)
    {
        printf("3");
    }
    else if (n == 5)
    {
        printf("2");
    }
    else if (n == 6)
    {
        printf("1");
    }
    else
    {
        printf("-1");
    }
    return 0;
}

//MT1129
//小码哥玩骰子
//小码哥抛出一个六面骰子。每个面上都印有一个数字，数字在1到6之间。输入正面的数字，请猜测对面的数字并输出两数之和。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n == 1)
    {
        printf("%d", 1 + 6);
    }
    else if (n == 2)
    {
        printf("%d", 2 + 5);
    }
    else if (n == 3)
    {
        printf("%d", 3 + 4);
    }
    else if (n == 4)
    {
        printf("%d", 3 + 4);
    }
    else if (n == 5)
    {
        printf("%d", 2 + 5);
    }
    else if (n == 6)
    {
        printf("%d", 6 + 1);
    }
    return 0;
}


//MT1130
//骰子里面的数学
//小码哥抛出一个六面骰子。每个面上都印有一个数字，数字在1到6之间。输入正面的数字，请猜测对面的数字并输出两数之差。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n == 1)
    {
        printf("%d", 1 - 6);
    }
    else if (n == 2)
    {
        printf("%d", 2 - 5);
    }
    else if (n == 3)
    {
        printf("%d", 3 - 4);
    }
    else if (n == 4)
    {
        printf("%d", 4 - 3);
    }
    else if (n == 5)
    {
        printf("%d", 5 - 2);
    }
    else if (n == 6)
    {
        printf("%d", 6 - 1);
    }
    return 0;
}

//MT1131
//字符判断
//输入一个字符，判断是数字字符、大写字母、小写字母、算术运算符、关系运算符、逻辑运算符，还是其他字符，分别输出“Number”, “Capital letter”，“Lowercase letter”，“Arithmetic operators”, “Relational operators”, “Logical operators”, “Other character”。
//
//格式
//输入格式：
//输入一个字符
//
//输出格式：
//输出字符

#include<stdio.h>
int main()
{
    char str = '0';
    scanf("%c", &str);
    if ((int)str >= 48 && (int)str <= 57)
    {
        printf("Number");
    }
    else if ((int)str >= 65 && (int)str <= 90)
    {
        printf("Capital letter");
    }
    else if ((int)str >= 97 && (int)str <= 122)
    {
        printf("Lowercase letter");
    }
    else if ((int)str >= 60 && (int)str <= 62)
    {
        printf("Relational operators");
    }
    else if (str == '+' || str == '-' || str == '*' || str == '/')
    {
        printf("Arithmetic operators");
    }
    else if (str == '!' || str == '&' || str == '|' || str == '^')
    {
        printf("Logical operators");
    }
    else
    {
        printf("Other character");
    }
    return 0;
}

//MT1132
//人民币大写数字
//输入一个金额，输出对应的人民币大写数字（零壹贰叁肆伍陆柒捌玖拾）。不考虑负数等不合理的输入。
//
//格式
//输入格式：
//输入为整型（ < 100）
//
//    输出格式：
//    输出字符

#include<stdio.h>
void Capital(int n)
{
    if (n == 0)
    {
        printf("零");
    }
    else if (n == 1)
    {
        printf("壹");
    }
    else if (n == 2)
    {
        printf("贰");
    }
    else if (n == 3)
    {
        printf("叁");
    }
    else if (n == 4)
    {
        printf("肆");
    }
    else if (n == 5)
    {
        printf("伍");
    }
    else if (n == 6)
    {
        printf("陆");
    }
    else if (n == 7)
    {
        printf("柒");
    }
    else if (n == 8)
    {
        printf("捌");
    }
    else if (n == 9)
    {
        printf("玖");
    }
    else if (n == 10)
    {
        printf("拾");
    }
}
int main()
{
    int num = 0;
    scanf("%d", &num);
    if (num <= 10)
    {
        Capital(num);
        printf("元整");
    }
    else
    {
        Capital(num / 10);
        printf("拾");
        num = num % 10;
        if (num == 0)
        {
            printf("元整");
        }
        else
        {
            Capital(num);
            printf("元整");
        }
    }
    return 0;
}

//MT1133
//小码哥打车
//小码哥在缅因州打车，那里只有Yellow cab，5个迈（Mile）以内收费10美元，里程大于5个迈小于等于10个迈的部分每个迈收费2美元，里程大于10个迈的部分每个迈收费2.5美元。不考虑负数，0或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为实型，保留2位小数


#include<stdio.h>
int main()
{
    int n;
    double cost = 0;
    scanf("%d", &n);
    if (n <= 5)
    {
        cost = 10;
        printf("%.2lf", cost);
    }
    else if (n <= 10)
    {
        cost = 10 + 2 * (n - 5);
        printf("%.2lf", cost);
    }
    else
    {
        cost = 20 + 2.5 * (n - 10);
        printf("%.2lf", cost);
    }
    return 0;
}

//MT1134
//简单计算
//编写一个模拟简单计算器的程序，计算表达式：a op b的值，要求 a、op、b从盘输入。其中a、b（作除数时不能为0）为数值，op为运算符 + 、－、 * 、 / 。本题不考虑非法输入等特殊情况。
//
//格式
//输入格式：
//输入数据和运算符
//
//输出格式：
//输出为实型

#include<stdio.h>
int main()
{
    double a, b;
    char op;
    scanf("%lf%c%lf", &a, &op, &b);

    if (op == '+')
    {
        printf("%lf\n", a + b);
    }
    else if (op == '-')
    {
        printf("%lf\n", a - b);
    }
    else if (op == '*')
    {
        printf("%lf\n", a * b);
    }
    else if (op == '/')
    {
        printf("%lf\n", a / b);
    }
    return 0;
}

//
//MT1135
//时间转换
//编写一个程序，输入24小时制的时间，然后以12小时的形式显示时间。不考虑负数或者其他特殊情况。注意不要把中午12 : 00显示为00 : 00，应该是12 : 00PM。凌晨00 : 00则是12 : 00AM。
//
//格式
//输入格式：
//输入为整型，冒号分隔
//
//输出格式：
//输出为整型，冒号分隔，以两位数的形式显示时间并加上后缀AM或者PM。

#include<stdio.h>
int main()
{
    int hour, minute;
    scanf("%d:%d", &hour, &minute);
    if (hour <= 12 && hour > 0)
    {
        if (hour == 12)
        {
            printf("%0*d:%0*dPM", 2, hour, 2, minute);
        }
        else
        {
            printf("%0*d:%0*dAM", 2, hour, 2, minute);
        }
    }
    else
    {
        if (hour == 0)
        {
            hour = 12;
            printf("%0*d:%0*dAM", 2, hour, 2, minute);
        }
        else
        {
            printf("%0*d:%0*dPM", 2, hour, 2, minute);
        }
    }
    return 0;
}

//MT1136 时间也能加
#include<stdio.h>
int main()
{
    int a[3], b[3], c[3];
    for (int i = 0; i < 3; i++)
    {
        scanf("%d", &a[i]);
    }
    for (int i = 0; i < 3; i++)
    {
        scanf("%d", &b[i]);
    }
    for (int i = 0; i < 3; i++)
    {
        c[i] = a[i] + b[i];
        if (c[i] > 59)
        {
            c[i] = c[i] - 60;
            c[i - 1] = c[i - 1] + 1;
        }
    }
    for (int i = 0; i < 3; i++)
    {
        printf("%d ", c[i]);
    }
    return 0;
}

//MT1137
#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n % 4 == 0 && n % 100 != 0)
    {
        printf("Y");
    }
    else if (n % 400 == 0)
    {
        printf("Y");
    }
    else
    {
        printf("N");
    }
    return 0;
}

//MT1138
//第几天
//输入日期（YYYY - M - D），然后输出它是一年中的第几天。不考虑负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int a, b, c;
    scanf("%d-%d-%d", &a, &b, &c);
    if ((a % 4 == 0 && a % 100 != 0) || a % 400 == 0)
    {
        printf("%d\n", 30 * (b - 1) + b / 2 + c - 1);
    }
    else
    {
        if (b == 1)
        {
            printf("%d\n", 30 * (b - 1) + b / 2 + c);
        }
        else
        {
            printf("%d\n", 30 * (b - 1) + b / 2 + c - 2);
        }

    }
    return 0;
}

//MT1139
//11或13
//输入正整数N，判断它是否可被11或13整除，输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if ((n % 11 == 0 || n % 13 == 0) && n != 0)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1140
//数字7
//输入一个整数N，判断它是不是整数7的和、差之类的。(比如某数等于7 + 7, 或者7 - 7, 或者7 - 7 - 7 + 7 + 7…)是则输出YES否则或者NO。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为YES或者NO

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n % 7 == 0 || n == 0)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1141
//数字13
//给您一个整数输入N，如果它是整数13的和或差(13 + 13, 13 - 13, 13 - 13 - 13 + 13 + 13…)，输出YES，否则输出NO。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为YES或者NO

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    if (n % 13 == 0 || n == 0)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1142
//整除的总数
//输入正整数N和M，其中N <= M。求区间[N，M]中可被K整除的总数。
//
//格式
//输入格式：
//输入正整数N，M和K，空格分隔。
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int a, b, x;
    scanf("%d %d %d", &a, &b, &x);
    int count = 0;
    for (int i = a; i <= b; i++)
    {
        if (i % x == 0 || i == 0)
        {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1143
#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    int temp = n, sum = 0;
    while (temp)
    {
        sum += temp % 10;
        temp /= 10;
    }
    if (n % sum == 0)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1144
//整除
//输入正整数N，检查它是否可以被其数字之和整除，输出YES或者NO。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO


#include<stdio.h>
int main()
{
    int N, sum = 0;
    scanf("%d", &N);
    int temp = N;
    while (temp)
    {
        sum += temp % 10;
        temp /= 10;
    }
    if (N % sum == 0)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1145
#include<stdio.h>
int main()
{
    int N, flag;
    scanf("%d", &N);
    for (int i = N;; i++)
    {
        flag = 1;
        for (int j = 1; j <= N; j++)
        {
            if (i % j != 0)
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
        {
            printf("%d", i);
            break;
        }
    }
    return 0;
}


//MT1146
//孙子歌诀
//存在一个数x，除以3余2，除以5余3，除以7余2，然后求这个数。明朝数学家程大位将解法编成易于上口的《孙子歌诀》 :
//
//三人同行七十稀，
//五树梅花廿一支，
//七子团圆正半月，
//除百零五使得知。
//
//3人同行“70” 稀，3的余数乘以70，5树梅花“21”支，5的余数乘以21，7子团圆正半月(15天)，7的余数乘以15。最后加在一起除以105看余数。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int x1, x2, x3;
    x1 = 2 * 70;
    x2 = 3 * 21;
    x3 = 2 * 15;
    printf("%d", (x1 + x2 + x3) % 105);
    return 0;
}

//MT1147
#include<stdio.h>
int main()
{
    for (int i = 1;; i++)
    {
        if (i % 3 == 2 && i % 5 == 3 && i % 7 == 2)
        {
            printf("%d", i);
            break;
        }
    }
    return 0;
}


//MT1148
//隐晦余8
//存在一个数x(大于10)，除以3余2，除以5余3，除以7余1，求这个数最小值。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int i = 0;
    while (1)
    {
        if ((i % 3 == 2 && i % 5 == 3) && (i % 7 == 1 && i > 10))
        {
            printf("%d", i);
            break;
        }
        else
        {
            i++;
        }
    }
    return 0;
}

//MT1149
//余数
//存在一个数x(大于10)，除以7余2，除以11余4，除以13余5，求这个数最小值。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int i = 0;
    while (1)
    {
        if ((i % 7 == 2 && i % 11 == 4) && (i % 13 == 5 && i > 10))
        {
            printf("%d", i);
            break;
        }
        else
        {
            i++;
        }
    }
    return 0;
}

//MT1150
//战死四五百
//带1500名兵士打仗，战死四五百人，站3人一排，多出2人；站5人一排，多出4人；站7人一排，多出6人。问战死多少人。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int i = 400;
    while (1)
    {
        int j = 1500;
        j -= i;
        if ((j % 3 == 2 && j % 5 == 4) && j % 7 == 6)
        {
            printf("%d", i);
            break;
        }
        else
        {
            i++;
        }
    }
    return 0;
}


//MT1151
//韩信生气
//韩信点兵(大于10人)，三个三个一排多2个，五个五个一排又多2个，七个七个一排还多2个。韩信生气了，怎么总多你俩，出去!问原本队伍里面最少应该有多少人。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int i = 0;
    while (1)
    {
        if ((i % 7 == 2 && i % 3 == 2) && (i % 5 == 2 && i > 10))
        {
            printf("%d", i);
            break;
        }
        else
        {
            i++;
        }
    }
    return 0;
}

//MT1152
//韩信又生气了
//韩信点兵(大于10人)，三个三个一排少1个人，五个五个一排又少1个人，七个七个一排还少1个人。韩信生气了，从别的队伍里调来一个人!这样不管是三个一排五个一排还是七个一排都完美了。问原本最少应该有多少人。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int i = 0;
    while (1)
    {
        if ((i % 7 == 6 && i % 3 == 2) && (i % 5 == 4 && i > 10))
        {
            printf("%d", i);
            break;
        }
        else
        {
            i++;
        }
    }
    return 0;
}

//MT1153
//真因子
//输入正整数N，计算其所有真因子之和。自然数的真因子是严格小于该数的除数。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, count = 0;
    scanf("%d", &N);
    for (int i = 1; i < N; i++)
    {
        if (N % i == 0)
        {
            count += i;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1154
//缺数
//若一个自然数的所有真因数之和比这个数小，此数就叫做缺数。输入正整数N，找出该数字是否为缺数输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int N, count = 0;
    scanf("%d", &N);
    for (int i = 1; i < N; i++)
    {
        if (N % i == 0)
        {
            count += i;
        }
    }
    if (count < N)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1155
//单位矩阵
//输入3X3的整型矩阵A，判断是否为单位矩阵，输出YES或者NO。
//
//格式
//输入格式：
//输入矩阵，空格分隔
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
#define N 9
int main()
{
    int a[N], flag = 1;
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }

    for (int i = 0; i < N; i++)
    {
        if (i == 0 || i == 4 || i == 8)
        {
            if (a[i] != 1)
            {
                flag = 0;
            }
        }
        else
        {
            if (a[i] != 0)
            {
                flag = 0;
            }
        }
    }
    if (flag == 1)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }

    return 0;
}


//MT1156
//稀疏矩阵
//输入3X3的整型矩阵A，判断是否为稀疏矩阵，输出YES或者NO。若矩阵中数值为0的元素数目多于非0元素的数目就叫做稀疏矩阵。
//
//格式
//输入格式：
//输入矩阵，空格分隔
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
#define N 9
int main()
{
    int a[N], i, count_0 = 0, count_1 = 0;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 0; i < N; i++)
    {
        if (a[i] == 0)
        {
            count_0++;
        }
        else
        {
            count_1++;
        }
    }
    if (count_0 > count_1)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1157
//矩阵相等
//输入4X4的整型矩阵A和B，判断是否为相等，输出YES或者NO。
//
//格式
//输入格式：
//输入矩阵，空格分隔。
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int a[4][4], b[4][4];
    int i, j, flag = 1;
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            scanf("%d", &b[i][j]);
        }
    }

    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            if (a[i][j] != b[i][j])
            {
                flag = 0;
                break;
            }
        }
    }

    if (flag == 1)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1158
#include<stdio.h>
int main()
{
    int N, M;
    scanf("%d %d", &N, &M);
    if (N >= ((M + 1) * M) / 2)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1159
//指定集合
//某数组含有N个元素，输出那些数字来自集合{ 4,5,6 }的元素，按原序。没有就输出 - 1。
//
//格式
//输入格式：
//第一行输入数组长度N，第二行输入数组元素，整型，空格分隔。
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
//#include<stdlib.h>
int main()
{
    int N, i;
    int flag = 1;
    scanf("%d", &N);
    int* num = (int*)malloc(sizeof(int) * N);
    for (i = 0; i < N; i++)
    {
        scanf("%d", &num[i]);
    }
    for (i = 0; i < N; i++)
    {
        if (num[i] == 4 || num[i] == 5 || num[i] == 6)
        {
            flag = 0;
            printf("%d ", num[i]);
        }
    }
    if (flag == 1)
    {
        printf("-1");
    }
    return 0;
}

//MT1160

#include<stdio.h>
int main()
{
    int N, factorial, count = 0;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        factorial = 1;
        for (int j = 1; j <= i; j++)
        {
            factorial *= j;
        }
        if (factorial % 10 == 0)
        {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1161
//N的零
//输入正整数N，将N的所有零转换为5。没有0就原样输出。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入正整数N
//
//
//输出格式：
//输出整型

#include<stdio.h>
#include<string.h>
int main()
{
    char a[100];
    scanf("%s", &a);
    for (int i = 0; i < strlen(a); i++)
    {
        if (a[i] == '0')
        {
            a[i] = '5';
        }
    }
    printf("%s", a);
    return 0;
}

//MT1162 数组最大公约数
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    int a[N];
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    int min = a[0], flag;
    for (int i = 0; i < N; i++)
    {
        if (min < a[i])
        {
            min = a[i];
        }
    }
    for (int i = min; i >= 1; i--)
    {
        flag = 1;
        for (int j = 0; j < N; j++)
        {
            if (a[j] % i != 0)
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
        {
            printf("%d", i);
            break;
        }
    }
    return 0;
}

//MT1163
//孪生质数
//在质数中，若两个质数之差为2, 我们称之为孪生质数, 例如（3、5）（5、7），输入2个正整数，判断他是不是孪生质数，输出YES或者NO。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出YES或者NO


// #include<stdio.h>
// #include<math.h>
// int main() 
// { 
//     int a, b, i;
//     scanf("%d %d", &a, &b);
//     int flag = 1;
//     for (i=2;i<=sqrt(a);i++)
//     {
//         if (a % i == 0 || a == 1)
//         {
//             flag = 0;
//             break;
//         }
//     }
//     for (i=2;i<=sqrt(b);i++)
//     {
//         if (b % i == 0 || b == 1)
//         {
//             flag = 0;
//             break;
//         }
//     }

//     if (flag == 0)
//     {
//         printf("NO");
//     }
//     else
//     {
//         if (b - a == 2 || a - b == 2)
//         {
//             printf("YES");
//         }
//         else
//         {
//             printf("NO");
//         }
//     }
//     return 0; 
// }

#include<stdio.h>
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    if ((b - a == 2 || a - b == 2) && (a != 0 && b != 0) && (a != 1 && b != 1))
    {
        for (int i = 2; i < a; i++)
        {
            if (a % i == 0)
            {
                printf("NO");
                return 0;
            }
            for (int i = 2; i < b; i++)
            {
                if (b % i == 0)
                {
                    printf("NO");
                    return 0;
                }
            }
        }
    }
    else
    {
        printf("NO");
        return 0;
    }
    printf("YES");
    return 0;
}

//MT1164
#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    int temp = n, min = temp % 10, flag = 1;
    while (temp)
    {
        if (temp % 10 <= min)
        {
            min = temp % 10;
        }
        else
        {
            flag = 0;
        }
        temp /= 10;
    }

    if (flag == 1)
    {
        printf("%d", n);
    }
    else
    {
        for (int i = n; i > 0; i--)
        {
            temp = i;
            flag = 1;
            min = temp % 10;
            while (temp)
            {
                if (temp % 10 <= min)
                {
                    min = temp % 10;
                }
                else
                {
                    flag = 0;
                }
                temp /= 10;
            }
            if (flag == 1)
            {
                printf("%d", i);
                break;
            }
        }
    }
    return 0;
}

//MT1165 卡罗尔数

#include<stdio.h>
int main()
{
    int N, num;
    scanf("%d", &N);
    for (int i = 2;; i++)
    {
        num = 2 * i - 3;
        if (num == N)
        {
            printf("YES");
            break;
        }
        else if (num > N)
        {
            printf("NO");
            break;
        }
    }
    return 0;
}


//MT1166 自守数
#include<stdio.h>
int main()
{
    int N, n, temp_N, temp_n;
    scanf("%d", &N);
    int temp = N, count = 0;
    n = N * N;
    while (temp)
    {
        temp /= 10;
        count++;
    }
    for (int i = 0; i < count; i++)
    {
        temp_N = N % 10;
        temp_n = n % 10;
        if (temp_N != temp_n)
        {
            printf("NO");
            return 0;
        }
        N /= 10;
        n /= 10;
    }
    printf("YES");
    return 0;
}

//MT1167
//自守数II
//输入正整数N，检查该数是否为自守数输出YES或者NO。当且仅当一个数的平方以与该数相同的数字结尾时，该数称为自守数。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    int NN = N * N;

    while (N)
    {
        if (N % 10 != NN % 10)
        {
            printf("NO");
            return 0;
        }
        N = N / 10;
        NN = NN / 10;
    }
    printf("YES");
    return 0;
}

//MT1168
//阶乘数
//输入正整数N，找出它是否是一个等于其他数的阶乘值的数，输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int N, num = 1, i;
    scanf("%d", &N);

    // for (i=1;i<=N;i++)
    // {
    //     num *= i;
    //     if (num == N)
    //     {
    //         printf("YES");
    //         return 0;
    //     }
    // }
    for (i = 1; i <= (N / 2) + 1; i++)
    {
        num *= i;
        if (num == N)
        {
            printf("YES");
            return 0;
        }
    }
    printf("NO");
    return 0;
}

//MT1169 平衡数
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    int temp = N, count = 0, sum1 = 0, sum2 = 0;
    while (temp)
    {
        temp /= 10;
        count++;
    }
    if (count == 1)
    {
        printf("YES");
    }
    else
    {
        for (int i = 1; i <= count; i++)
        {
            if (i < (count - 1) / 2 + 1)
            {
                sum1 += N % 10;
            }
            else if (i > (count - 1) / 2 + 1)
            {
                sum2 += N % 10;
            }
            N /= 10;
        }
    }
    if (sum1 == sum2)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1170
//四叶玫瑰数
//输入正整数N，判断它是不是一个四叶玫瑰数，输出YES或者NO。四位玫瑰数是4位数的自幂数，它的每个位上的数字的4次幂之和等于它本身。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<math.h>
int main()
{
    int N, sum = 0;
    scanf("%d", &N);
    int temp = N;

    while (temp)
    {
        sum += pow((double)(temp % 10), 4.0);
        temp /= 10;
    }
    if (N == sum && (N >= 1000 && N <= 9999))
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1171
//幻数
//一个数字，把他的各位数累加会得到一个新的数字，再把这个新数字的每一位加起来，重复这个过程，直到只剩下一位数字，如果最后剩下的数字是1，就称原数为一个幻数。输入正整数N，检查它是否是一个幻数，输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int LeiJia(int num)
{
    int sum = 0;
    while (num)
    {
        sum += num % 10;
        num /= 10;
    }
    return sum;
}
int main()
{
    int N;
    scanf("%d", &N);
    while (N >= 10)
    {
        N = LeiJia(N);
    }
    if (N == 1)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1172
//完美数字
//输入正整数N，检查它是否完美输出YES或者NO。把一个数字的每一位拆分开，计算他们的阶乘再累加，如果和等于原数字，则该数字是完美的。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int N, i;
    scanf("%d", &N);
    int num, sum = 0, temp = N;
    while (temp)
    {
        num = 1;
        for (i = 1; i <= temp % 10; i++)
        {
            num *= i;
        }
        sum += num;
        temp /= 10;
    }
    if (sum == N)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1173
//魔数
//一个数字，把他乘以二，会得到一个新的数字，如果这个新数字依然由原数中那些数字组成，就称原数为一个魔数。输入正整数N，检查它是否是一个魔数，输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    int temp1, temp2 = N / 2, flag;
    while (temp2)
    {
        temp1 = N;
        flag = 0;
        while (temp1)
        {
            if (temp1 % 10 == temp2 % 10)
            {
                flag = 1;
            }
            temp1 /= 10;
        }
        if (flag != 1)
        {
            printf("NO");
            return 0;
        }
        temp2 /= 10;
    }
    printf("YES");
    return 0;
}

//MT1174
//A的B次方
//输入正整数N，判断它是否可以表示为A的B次方，其中B > 1，A > 0，都是整数。输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
#include<math.h>
int main()
{
    int N, i, j;
    scanf("%d", &N);
    for (i = 1; i <= sqrt(N) + 1; i++)
    {
        for (j = 2; j <= sqrt(N) + 1; j++)
        {
            if (pow(i, j) == N)
            {
                printf("YES");
                return 0;
            }
        }
    }
    printf("NO");
    return 0;
}

//MT1175 网球比赛
#include<stdio.h>
int main()
{
    char a[2][3] = { {'a', 'b', 'c'}, {'x', 'y', 'z'} };
    for (int i = 3; i <= 3; i++)
    {
        for (int j = 1; i <= 3; j++)
        {
            for (int k = 2; k <= 2; k++)
            {
                if (i != j && j != k && i != k)
                {
                    printf("%c with %c\n", a[0][0], a[1][i - 1]);
                    printf("%c with %c\n", a[0][1], a[1][j - 1]);
                    printf("%c with %c", a[0][2], a[1][k - 1]);
                    return 0;
                }
            }
        }
    }
    return 0;
}


//MT1176
//两个点的距离
//给定笛卡尔平面上两个点的坐标，求它们之间的距离向上舍入为最接近的整数。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型

#include<stdio.h>
#include<math.h>
int main()
{
    int x1, x2, y1, y2;
    scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
    // printf("%.0lf\n", sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)));
    int sum = pow(x1 - x2, 2) + pow(y1 - y2, 2);
    int num = sqrt(sum);
    if (num * num == sum)
    {
        printf("%d\n", num);
    }
    else
    {
        printf("%d\n", num + 1);
    }
    return 0;
}

//MT1177 三角形

#include<stdio.h>
#include<math.h>
int main()
{
    int x1, y1, x2, y2, x3, y3;
    int xN, yN;
    scanf("%d %d %d %d %d %d", &x1, &y1, &x2, &y2, &x3, &y3);
    scanf("%d %d", &xN, &yN);
    double S, S1, S2, S3;
    S = (double)(x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2) * 0.5;
    S1 = (double)(x1 * yN + xN * y3 + x3 * y1 - x1 * y3 - xN * y1 - x3 * yN) * 0.5;
    S2 = (double)(xN * y2 + x2 * y3 + x3 * yN - xN * y3 - x2 * yN - x3 * y2) * 0.5;
    S3 = (double)(x1 * y2 + x2 * yN + xN * y1 - x1 * yN - x2 * y1 - xN * y2) * 0.5;
    if (S < 0 || S1 < 0 || S2 < 0 || S3 < 0)
    {
        S = sqrt(S * S);
        S1 = sqrt(S1 * S1);
        S2 = sqrt(S2 * S2);
        S3 = sqrt(S3 * S3);
    }
    if (S < S1 + S2 + S3)
    {
        printf("NO");
    }
    else if (S == S1 + S2 + S3)
    {
        printf("YES");
    }
    return 0;
}

//MT1178
//点与线段的关系
//输入线段的2个端点的坐标值x和y，再输入第3个点的坐标，判断点在不在线段上，输出YES或者NO。
//
//格式
//输入格式：
//按照先起点（x, y）再终点（x, y）的次序。第二行输入第3个点的坐标。坐标整型。第一行两点之间空格，如样例所示。
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
#include<math.h>
int main()
{
    double x1, y1, x2, y2, a, b;
    scanf("(%lf,%lf) (%lf,%lf) \n (%lf,%lf)", &x1, &y1, &x2, &y2, &a, &b);
    double xy = sqrt(pow(x1 - x2, 2.0) + pow(y1 - y2, 2.0));
    double xy1 = sqrt(pow(x1 - a, 2.0) + pow(y1 - b, 2.0));
    double xy2 = sqrt(pow(x2 - a, 2.0) + pow(y2 - b, 2.0));
    if (xy1 + xy2 == xy)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1179 线段与线段的关系
#include<stdio.h>
// #include<math.h>
int main()
{
    int x1, y1, x2, y2;
    int x3, y3, x4, y4;
    scanf("(%d,%d) (%d,%d)\n", &x1, &y1, &x2, &y2);
    scanf("(%d,%d) (%d,%d)", &x3, &y3, &x4, &y4);
    // if ((x1 == x2 && x3 == x4) || (y1 == y2 && y3 == y4))
    // {
    //     printf("YES");
    //     return 0;
    // }
    // double tan1, tan2;
    // tan1 = sqrt(pow((double)(y2 - y1), 2.0)) / sqrt(pow((double)(x2 - x1), 2.0));
    // tan2 = sqrt(pow((double)(y4 - y3), 2.0)) / sqrt(pow((double)(x4 - x3), 2.0));
    // if (tan1 == tan2)
    // {
    //     printf("YES");
    // }
    // else
    // {
    //     printf("NO");
    // }
    if (x1 == x2 && x3 == x4 || y1 == y2 && y3 == y4)
    {
        printf("YES");
    }
    else if ((y2 - y1) / (x2 - x1) == (y4 - y3) / (x4 - x3))
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1181
#include<stdio.h>
#include<math.h>
int main()
{
    int x1, y1, r1;
    int x2, y2, r2;
    scanf("%d %d %d", &x1, &y1, &r1);
    scanf("%d %d %d", &x2, &y2, &r2);
    int AB;
    if (r1 > r2)
    {
        AB = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
        if (AB < (r1 - r2))
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
    else if (r1 < r2)
    {
        AB = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
        if (AB < (r2 - r1))
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1182 圆相交
#include<stdio.h>
#include<math.h>
int main()
{
    int x1, y1, r1, x2, y2, r2;
    scanf("%d %d %d", &x1, &y1, &r1);
    scanf("%d %d %d", &x2, &y2, &r2);
    int AB = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    if (r1 >= r2)
    {
        if (AB >= (r1 - r2) && AB < (r1 + r2))
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
    else
    {
        if (AB >= (r2 - r1) && AB < (r1 + r2))
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
    return 0;
}


//MT1183
//矩形包含
//输入2个矩形的左上角和右下角两个点的坐标值（x，y），判断2个矩形是否相互包含（一个在另一个内部，边框不重叠），输出YES或者NO。矩形的边应与x，y轴相平行。
//
//格式
//输入格式：
//输入整型，空格分隔。 每行输入一组信息。
//
//输出格式：
//输出YES或者NO


#include<stdio.h>
int main()
{
    int x1, y1, x2, y2, x3, y3, x4, y4;
    scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
    scanf("%d %d %d %d", &x3, &y3, &x4, &y4);
    if ((x1 < x3 && x3 < x2 && y3 < y1 && y3 > y2) && (x1 < x4 && x4 < x2 && y4 < y1 && y4 > y2))
    {
        printf("YES");
    }
    else if ((x3 < x1 && x1 < x4 && y1 < y3 && y1 > y4) && (x3 < x2 && x2 < x4 && y2 < y3 && y2 > y4))
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1185
//while循环
//请编写一个简单程序，从小到大输出所有小于8的正整数和0（从0开始输出）。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型，空格分隔


#include<stdio.h>
int main()
{
    int i = 0;
    while (i < 8)
    {
        printf("%d ", i);
        i++;
    }
    return 0;
}


//MT1186
//do - while循环
//请编写一个简单程序，从大到小输出所有小于n的正整数，直到0为止(不含0)。n从键盘输入
//
//格式
//输入格式：
//输入整型数n
//
//输出格式：
//输出整型，空格分隔


#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    do
    {
        printf("%d ", n);
        n--;
    } while (n);
    return 0;
}

//MT1187
//累加和
//从1累加到10，输出累加和
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型


#include<stdio.h>
int main()
{
    int i;
    int sum = 0;
    for (i = 0; i <= 10; i++)
    {
        sum += i;
    }
    printf("%d", sum);
    return 0;
}


//MT1188
//平均值
//请编写一个简单程序，随机输入n个数字，输出他们的平均值
//
//格式
//输入格式：
//输入分两行，第一行输入n，第二行输入n个float型数据，空格分隔
//
//输出格式：
//输出float型，空格分隔，保留2位小数



#include<stdio.h>
int main()
{
    int n, i;
    float temp, sum = 0;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%f", &temp);
        sum += temp;
    }
    printf("%.2f", sum / n);
    return 0;
}

//MT1189
//正数负数的和
//编写程序先输入n，再输入n个实数并分别统计正数的和、负数的和，然后输出统计结果。
//
//格式
//输入格式：
//输入分两行，第一行输入整数n，第二行输入n个实数，空格分隔。
//
//输出格式：
//输出正数的和，和负数的和，实型，中间一个空格


#include<stdio.h>
int main()
{
    int n, i;
    double temp, p_sum = 0, n_sum = 0;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%lf", &temp);
        if (temp >= 0)
        {
            p_sum += temp;
        }
        else
        {
            n_sum += temp;
        }
    }
    printf("%lf %lf", p_sum, n_sum);
    return 0;
}


//MT1190
//分数乘法
//输入5组分数，对他们进行乘法运算，输出结果。不考虑分母为0等特殊情况。
//
//格式
//输入格式：
//输入整型，每组一行，如样例所示。
//
//输出格式：
//输出计算结果实型，如样例所示。

#include<stdio.h>
int main()
{
    double x1, y1, x2, y2, i, result;
    for (i = 0; i < 5; i++)
    {
        scanf("%lf/%lf %lf/%lf", &x1, &y1, &x2, &y2);
        result = (x1 / y1) * (x2 / y2);
        printf("%lf\n", result);
    }
    return 0;
}


//MT1191
//减半
//输入两个值N和M，输出N做M次减半后的值。比如100，减半后依次为50, 25, 12…，减半3次后是12。输入不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int N, M;
    scanf("%d %d", &N, &M);
    for (int i = 0; i < M; i++)
    {
        N /= 2;
    }
    printf("%d", N);
    return 0;
}


//MT1192
//翻倍
//输入两个值N和M。输出N做M次翻倍后的值。比如12，翻倍后依次为24, 48, 96…。输入不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型


#include<stdio.h>
int main()
{
    int N, M;
    scanf("%d %d", &N, &M);
    for (int i = 0; i < M; i++)
    {
        N *= 2;
    }
    printf("%d", N);
    return 0;
}

//MT1193
//偶数的平方和
//输入正整数N，求前N个偶数的平方和。不考虑溢出。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输入整型


#include<stdio.h>
int main()
{
    int N, i, sum = 0;
    scanf("%d", &N);
    for (i = 2; i <= 2 * N; i)
    {
        sum += i * i;
        i += 2;
    }
    printf("%d\n", sum);
    return 0;
}



//MT1194
//奇数的平方和
//输入正整数N，求前N个奇数的平方和。不考虑溢出。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输入整型


#include<stdio.h>
int main()
{
    int N, i, sum = 0;
    scanf("%d", &N);
    for (i = 1; i <= 2 * N - 1; i)
    {
        sum += i * i;
        i += 2;
    }
    printf("%d\n", sum);
    return 0;
}

//MT1195
//公式求和
//输入正整数N和M，按照下列公式求和。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出实型

#include<stdio.h>
int main()
{
    int N, M, i;
    double sum = 0;
    scanf("%d %d", &N, &M);
    for (i = N; i <= M; i++)
    {
        sum += 1.0 / (i * i);
    }
    printf("%.5lf", sum);
    return 0;
}

//MT1196
//阶乘
//请编写一个简单程序，输入正整数n，输出n的阶乘。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int n, sum = 1;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        sum *= i;
    }
    printf("%d!=%d", n, sum);
    return 0;
}

//MT1197
//阶乘和
//求1!+ 2!+ 3!+ … + n!
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n, num, sum = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        num = 1;
        for (int j = 1; j <= i; j++)
        {
            num *= j;
        }
        sum += num;
    }
    printf("%d", sum);
    return 0;
}

//MT1198
//阶乘差
//求1!- 2!- 3!- … - n!
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n, num, sum = 2;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        num = 1;
        for (int j = 1; j <= i; j++)
        {
            num *= j;
        }
        sum -= num;
    }
    printf("%d", sum);
    return 0;
}

//MT1199
//公式计算
//输入正整数n和r，计算公式(n!) / (n - r)!。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//输出实型，保留2位小数。


#include<stdio.h>
int main()
{
    int n, r, i;
    scanf("%d %d", &n, &r);
    double num1 = 1, num2 = 1;
    for (i = 1; i <= n; i++)
    {
        num1 *= i;
    }
    for (i = 1; i <= (n - r); i++)
    {
        num2 *= i;
    }
    printf("%.2lf\n", num1 / num2);
    return 0;
}


//MT1200
//常数e
//常数e的值可以表示为无穷级数： e = 1 + 1 / 1!+ 1 / 2!+ 1 / 3!+ … 1 / n!编写一个程序，计算e的值，其中n是用户输入的整数。输入不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为实型，保留两位小数


#include<stdio.h>
int main()
{
    int n, sum;
    double e = 1;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        sum = 1;
        for (int j = 1; j <= i; j++)
        {
            sum *= j;
        }
        e += 1.0 / sum;
    }
    printf("%.2lf", e);
    return 0;
}

//MT1201
//强数
//强数是各位数字的阶乘和等于原始数的数，输入一个数字N，检查它是否为强数。是则输出YES，否则输出NO。比如145，1！ + 4！ + 5！ = 145
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为YES或者NO

#include<stdio.h>
int main()
{
    int N, i, num;
    scanf("%d", &N);
    int temp = N, sum = 0;

    while (temp)
    {
        num = 1;
        for (i = 1; i <= temp % 10; i++)
        {
            num *= i;
        }
        sum += num;
        temp /= 10;
    }
    if (sum == N)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1202 克里希那穆提数
#include<stdio.h>
int main()
{
    int a, b, temp, num, sum;
    scanf("%d %d", &a, &b);
    for (int i = a; i <= b; i++)
    {
        temp = i;
        sum = 0;
        while (temp)
        {
            num = 1;
            if (temp % 10)
            {
                for (int j = 1; j <= temp % 10; j++)
                {
                    num *= j;
                }
            }
            temp /= 10;
            sum += num;
        }
        if (sum == i && sum != 0)
        {
            printf("%d ", i);
        }
    }
    return 0;
}


//MT1203
//字母矩阵
//请编写一个简单程序，输入正整数n，输出n* n的F字矩阵
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出n* n的F字矩阵，空格分隔

#include<stdio.h>
int main()
{
    int n, i, j;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("F ");
        }
        printf("\n");
    }
    return 0;
}

//MT1204
//字母三角
//请编写一个简单程序，输入正整数n，输出n行F字三角
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出n行F字三角



#include<stdio.h>
int main()
{
    int i, j, n;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        for (j = 0; j < 2 * i - 1; j++)
        {
            printf("F");
        }
        printf("\n");
    }
    return 0;
}

//MT1205
//倒三角
//请编写一个简单程序，输入正整数n，输出n行F字倒三角
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出n行F字倒三角

#include<stdio.h>
int main()
{
    int i, j, n;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n - i; j++)
        {
            printf("F");
        }
        printf("\n");
    }
    return 0;
}


//MT1206
//金字塔
//请编写一个简单程序，输入正整数n，输出n行W字金字塔
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出n行W字金字塔


#include<stdio.h>
int main()
{
    int i, n, x, y;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        for (x = 1; x <= n - i; x++)
        {
            printf(" ");
        }
        for (y = 1; y <= 2 * i - 1; y++)
        {
            printf("W");
        }
        printf("\n");
    }
    return 0;
}

//MT1207
//倒金字塔
//请编写一个简单程序，输入正整数n，输出n行W字金字塔。(第一行左边不空格)
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出n行W字倒金字塔



#include<stdio.h>
int main()
{
    int i, n, x, y;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        x = i;
        while (x - 1)
        {
            printf(" ");
            x--;
        }
        for (y = 1; y <= n + 1 - i; y++)
        {
            printf("W ");
        }
        printf("\n");
    }
}

//MT1208
//菱形
//请编写一个简单程序，输入正整数n，输出n行W字菱形。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出W字菱形


// #include<stdio.h>
// int main() 
// { 
//     int x, i, j, k;
//     scanf("%d", &x);
//     for (i=1;i<=x;i++)
//     {
//         for (j=x-i;j<=0;j--)
//         {
//             printf(" ");
//         }
//         for (k=1;k<=i;k++)
//         {
//             printf("W ");
//         }
//         printf("\n");
//     }
//     for (i=1;i<x;i++)
//     {
//         for (j=1;j<=i;j++)
//         {
//             printf(" ");
//         }
//         for (k=1;k<=x-i;k++)
//         {
//             printf("W ");
//         }
//         printf("\n");
//     }
//     return 0; 
// }

// #include<stdio.h>
// int main() 
// {
//     int i, n, x, y;
//     scanf("%d", &n);

//     for (i=1;i<=n;i++)
//     {
//         for (x=1;x<=n-i;x++)
//         {
//             printf(" ");
//         }
//         for (y=1;y<=2*i-1;y++)
//         {
//             printf("W ");
//         }
//         printf("\n");
//     }
//     printf("\n");
//     for (i=1;i<=n;i++)
//     {
//         x = i;
//         while (x-1)
//         {
//             printf(" ");
//             x--;
//         }
//         for (y=1;y<=n+1-i;y++)
//         {
//             printf("W ");
//         }
//         printf("\n");
//     } 
// }
// #include<stdio.h>
// int main() 
// {
//     int i, n, x, y;
//     scanf("%d", &n);
//     for (i=1;i<=n;i++)
//     {
//         for (x=1;x<=n-i;x++)
//         {
//             printf(" ");
//         }
//         for (y=1;y<=2*i-1;y++)
//         {
//             printf("W");
//         }
//         printf("\n");
//     }
//     return 0; 
// }


#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= 2 * n - 1; i++)
    {
        if (i < n)
        {
            for (int j = n - i; j > 0; j--)
            {
                printf(" ");
            }
        }
        else if (i > n)
        {
            for (int j = 1; j <= i - n; j++)
            {
                printf(" ");
            }
        }

        if (i <= n)
        {
            for (int j = 1; j <= i; j++)
            {
                printf("W ");
            }
        }
        else
        {
            for (int j = 1; j <= n - (i - n); j++)
            {
                printf("W ");
            }
        }
        printf("\n");
    }
    return 0;
}


//MT1209 沙漏
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
    {
        if (i >= 1)
        {
            for (int j = 0; j < i; j++)
            {
                printf(" ");
            }
        }
        for (int j = i; j < N; j++)
        {
            printf("W ");
        }
        printf("\n");
    }
    for (int i = 0; i < N; i++)
    {
        if (i < N - 1)
        {
            for (int j = 0; j < N - 1 - i; j++)
            {
                printf(" ");
            }
        }
        for (int j = 0; j < i + 1; j++)
        {
            printf("W ");
        }
        printf("\n");
    }
    return 0;
}


//MT1210
//弗洛伊德三角
//输入正整数N。输出N行的弗洛伊德三角形
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型，空格分隔

#include<stdio.h>
int main()
{
    int N, i, j, x = 0;
    scanf("%d", &N);
    for (i = 1; i <= N; i++)
    {
        for (j = 1; j <= i; j++)
        {
            x++;
            printf("%d ", x);
        }
        printf("\n");
    }
    return 0;
}


//MT1211
//给定数字的乘法表
//输出给定数字N的乘法表。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型，空格分隔


#include<stdio.h>
int main()
{
    int N, i;
    scanf("%d", &N);
    for (i = 1; i <= 9; i++)
    {
        printf("%d ", N * i);
    }
    return 0;
}


//MT1212
//乘法表
//请编写一个简单程序，输出九九乘法表。输入n，就输出乘法表到n的地方。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型。形式如：1 * 1 = 1




#include<stdio.h>
int main()
{
    int n, i, j;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= i; j++)
        {
            printf("%d*%d=%-2d ", i, j, i * j);
        }
        printf("\n");
    }
    return 0;
}

//MT1213
//x个a
//求a + aa + aaa + … + a…a（x个a），x和a由键盘输入。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型求a + aa + aaa + … + a…a（x个a），x和a由键盘输入。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int x, a, temp, i, num = 1, sum = 0;
    scanf("%d %d", &x, &a);
    for (i = 1; i < x; i++)
    {
        num *= 10;
    }
    for (i = 1; i <= x; i++)
    {
        temp = a * i;
        sum += temp * num;
        num /= 10;
    }
    printf("%d", sum);
    return 0;
}




//MT1214
//上三角矩阵
//输入3X3的整型矩阵A，输出对应的上三角矩阵。
//
//格式
//输入格式：
//输入矩阵，元素在0到9之间，空格分隔。
//
//输出格式：
//输出矩阵，空格分隔。

#include<stdio.h>
#define N 9
#define X 3
#define Y 3
int main()
{
    int a[N], i, j, count;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    count = 0;
    for (i = 0; i < X; i++)
    {
        for (j = 0; j < Y; j++)
        {
            if (count == 3 || count == 6 || count == 7)
            {
                printf("0 ");
            }
            else
            {
                printf("%d ", a[count]);
            }
            count++;
        }
        printf("\n");
    }
    return 0;
}

//MT1215
//下三角矩阵
//输入3X3的整型矩阵A，输出对应的下三角矩阵。
//
//格式
//输入格式：
//输入矩阵，元素在0到9之间，空格分隔。
//
//输出格式：
//输出矩阵，空格分隔。


#include<stdio.h>
#define N 9
#define X 3
#define Y 3
int main()
{
    int a[N], i, j, count;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    count = 0;
    for (i = 0; i < X; i++)
    {
        for (j = 0; j < Y; j++)
        {
            if (count == 1 || count == 2 || count == 5)
            {
                printf("0 ");
            }
            else
            {
                printf("%d ", a[count]);
            }
            count++;
        }
        printf("\n");
    }
    return 0;
}
//
//MT1216
//数组加法
//有两个数组A和B，他们都有N个整型元素，编写一个函数，实现他们的“加法”把对应元素相加，结果放在C数组的对应位置，输出C数组。
//
//格式
//输入格式：
//第一行输入数组长度N，后两行分别输入A，B数组的元素，整型，空格分隔。
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int main()
{
    int N, i;
    scanf("%d", &N);
    int A[N], B[N], C[N];
    for (i = 0; i < N; i++)
    {
        scanf("%d", &A[i]);
    }
    for (i = 0; i < N; i++)
    {
        scanf("%d", &B[i]);
    }
    for (i = 0; i < N; i++)
    {
        C[i] = A[i] + B[i];
    }
    for (i = 0; i < N; i++)
    {
        printf("%d ", C[i]);
    }
    return 0;
}

//MT1217
//矩阵乘法
//输入3X4整型矩阵A和4X3的整型矩阵B，计算A* B，放到矩阵C里面，输出矩阵C。
//
//格式
//输入格式：
//分两行输入两个矩阵，空格分隔。
//
//输出格式：
//按矩阵形式输出，整型，每个数字占3列，空格分隔。


#include<stdio.h>
int main()
{
    int A[3][4], B[4][3], C[3][3];
    int i, j, k, num;
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 4; j++)
        {
            scanf("%d", &A[i][j]);
        }
    }
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 3; j++)
        {
            scanf("%d", &B[i][j]);
        }
    }

    for (k = 0; k < 3; k++)
    {
        for (i = 0; i < 3; i++)
        {
            num = 0;
            for (j = 0; j < 4; j++)
            {
                num += A[k][j] * B[j][i];
            }
            C[k][i] = num;
        }
    }

    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            printf("%3d ", C[i][j]);
        }
        printf("\n");
    }
    return 0;
}

//
//MT1218
//斐波那契数列
//请编写一个简单程序，求斐波那契数列前10个数
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型，空格分隔


#include<stdio.h>
#define N 10
int main()
{
    int a[N], i;
    a[0] = 1;
    for (i = 0; i < N; i++)
    {
        if (i - 2 >= 0)
        {
            a[i] = a[i - 1] + a[i - 2];
        }
        else if (i - 1 >= 0)
        {
            a[i] = a[i - 1] + 0;
        }
        else
        {
            a[i] = a[i];
        }
    }
    for (i = 0; i < N; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}


//MT1219
//斐波那契数列II
//判断数字N（N <
//    2
//    9
//    2
//    9
//    ）是否为斐波那契数列中出现的数，输出YES或者NO。
//
//    格式
//    输入格式：
//    输入整型
//
//    输出格式：
//    输出YES或者NO

// #include<stdio.h>
// #include<math.h>
// int main() 
// { 
//     int N, a[100] = {0, 1, 2};
//     scanf("%d", &N);
//     int i = 3;
//     do{
//         a[i] = a[i-1] + a[i-2];
//         if (a[i] == N)
//         {
//             printf("YES");
//             return 0;
//         }
//         i++;
//     }while (a[i] <= N);
//     printf("NO");
//     return 0; 
// }

#include<stdio.h>
int main()
{
    int N, a = 0, b = 1, c = 2;
    scanf("%d", &N);
    if (N == 1 || N == 2 || N == 0)
    {
        printf("YES");
        return 0;
    }
    while (c <= N)
    {
        c = a + b;
        a = b;
        b = c;
        if (c == N)
        {
            printf("YES");
            return 0;
        }
    }
    printf("NO");
    return 0;
}

//MT1220
//斐波那契数列III
//输入一个正整数N（N < 50），输出斐波那契数列前N项。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型，空格分隔。
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    int a[N], i;
    a[0] = 1;
    for (i = 0; i < N; i++)
    {
        if (i - 2 >= 0)
        {
            a[i] = a[i - 1] + a[i - 2];
        }
        else if (i - 1 >= 0)
        {
            a[i] = a[i - 1] + 0;
        }
        else
        {
            a[i] = a[i];
        }
    }
    for (i = 0; i < N; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}


//MT1221
//分数的总和
//有一个分数序列： 2 / 1，3 / 2，5 / 3，8 / 5，13 / 8，21 / 13 …，计算前20个分数的总和
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为实型，保留2位小数

#include<stdio.h>
#define N 20
int main()
{
    double a[N], b[N], sum = 0;
    int i;
    a[0] = 1.0;
    a[1] = 2.0;
    b[0] = 2.0;
    b[1] = 3.0;
    for (i = 2; i < N; i++)
    {
        a[i] = a[i - 1] + a[i - 2];
        b[i] = b[i - 1] + b[i - 2];
    }
    //校验数据
    // for (i=0;i<N;i++)
    // {
    //     printf("%lf %lf\n", a[i], b[i]);
    // }
    for (i = 0; i < N; i++)
    {
        sum = sum + (b[i] / a[i]);
    }
    printf("%.2lf", sum);
}

//MT1222
//等差数列
//求等差数列前N项的级数之和。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入N，首项M，差值K，整型，空格分隔。
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, M, K;
    scanf("%d %d %d", &N, &M, &K);
    printf("%d\n", M * N + N * (N - 1) * K / 2);
    return 0;
}

//MT1223
//N是什么
//给定一系列数字3、10、21、36…，输入正整数N，输出上述序列的第N个值。从N = 1开始计数。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出整型

// #include<stdio.h>
// int main() 
// {
//     int N, num;
//     scanf("%d", &N);
//     int j = 3;
//     for (int i = 1;i<=N;i++)
//     {
//         num = i * j;
//         j += 2;
//     }
//     printf("%d\n", num);
//     return 0; 
// }

#include<stdio.h>
int main()
{
    int N, num, i = 3;
    scanf("%d", &N);
    num = N * (i + 2 * (N - 1));
    printf("%d\n", num);
}

//MT1224
//棋盘
//求一个N* N棋盘中的方块总数。
//
//格式
//输入格式：
//输入整型N
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N;
    long count = 0;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        count += (i * i);
    }
    printf("%ld", count);
    return 0;
}

//MT1225 复杂分数
#include<stdio.h>
int main()
{
    double a[5];
    for (int i = 0; i < 5; i++)
    {
        scanf("%lf", &a[i]);
    }
    double num = a[4];
    for (int i = 3; i >= 0; i--)
    {
        num = 1 + a[i] / num;
    }
    printf("%lf", num);
    return 0;
}


//MT1226
//解不等式
//n为正整数，求解n满足不等式 :
//�
//<
//    1
//    +
//    1
//    1
//    +
//    1
//    /
//    2
//    +
//    1
//    1
//    +
//    1
//    /
//    2
//    +
//    1
//    /
//    3
//    +
//    …
//    +
//    1
//    1
//    +
//    1
//    /
//    2
//    +
//    1
//    /
//    3
//    +
//    …
//    +
//    1
//    /
//    �
//    <
//    �
//    a < 1 +
//    1 + 1 / 2
//    1
//    ​
//    +
//    1 + 1 / 2 + 1 / 3
//    1
//    ​
//    + … +
//    1 + 1 / 2 + 1 / 3 + … + 1 / n
//    1
//    ​
//    < b
//
//    格式
//    输入格式：
//    输入正整数a，b，空格分隔。
//
//    输出格式：
//    输出整型区间上下限，空格分隔。


#include<stdio.h>
int main()
{
    int a, b, n1, n2;
    scanf("%d %d", &a, &b);
    double sum = 0, num = 0;
    for (int i = 1;; i++)
    {
        num += (1.0 / (double)i);
        sum += 1.0 / num;
        if (a < sum)
        {
            n1 = i;
            break;
        }
    }
    for (int i = n1 + 1;; i++)
    {
        num += (1.0 / (double)i);
        sum += 1.0 / num;
        if (b <= sum)
        {
            n2 = i - 1;
            break;
        }
    }
    printf("%d %d", n1, n2);
    return 0;
}


//MT1227 
//宝宝爬楼梯
//楼梯有N个台阶(N <= 10)，宝宝想爬到顶部。她一次可以爬1级或2级台阶。统计宝宝可以用多少种方式爬到达顶端。
//输入格式 : 输入正整数N
//输出格式 : 输出整型

#include<stdio.h>
int main()
{
    int a[10] = { 0, 1, 2 };
    int N;
    scanf("%d", &N);
    for (int i = 3; i <= N; i++)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    printf("%d\n", a[N]);
    return 0;
}

//MT1228
//宝宝抢糖果
//宝宝们一起抢N个糖果（N <= 10），手快的宝宝可以抢到2个糖果，手慢的只能抢到一个糖果。统计糖果可以多少种方式被瓜分。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, a[10] = { 0, 1, 2 };
    scanf("%d", &N);
    for (int i = 3; i <= N; i++)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    printf("%d\n", a[N]);
    return 0;
}



//MT1229 搬家公司
#include<stdio.h>
int main()
{
    int N, a[100] = { 0, 1, 2 };
    scanf("%d", &N);
    for (int i = 3; i <= N; i++)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    printf("%d", a[N]);
    return 0;
}

//MT1230
//圆周率
//编写一个程序，使用以下公式计算PI的近似值PI = 4（1 - 1 / 3 + 1 / 5 - 1 / 7 + 1 / 9…）。括号中的最后一项应小于十的负六次方。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为实型，保留2位小数

// #include<stdio.h>
// #include<math.h>
// int main() 
// { 
//     double sum = 0, n = 1, a;
//     double E = pow(10.0, -6.0);
//     while (1.0 / a >= E)
//     {
//         sum += 1.0 / n;
//         n = -(n + 2);
//         a = sqrt(n * n);
//     }
//     printf("%.2lf", 4 * sum);
//     return 0; 
// }

#include<stdio.h>
int main()
{
    double x = 0, PI = 0;
    for (int i = 1;; i += 2)
    {
        x = 1 / (double)i;
        if (x < 1e-6)
        {
            break;
        }
        if (i % 4 == 3)
        {
            x = -x;
        }
        PI += x;
    }
    printf("%.2lf\n", 4 * PI);
    return 0;
}


//MT1231圆周率II
#include<stdio.h>
int main()
{
    double num = 1;
    for (double i = 1; i <= 1000000; i++)
    {
        if ((int)i % 2)
        {
            num *= ((i + 1) / i);
        }
        else
        {
            num *= (i / (i + 1));
        }
    }
    printf("%.2lf", num * 2);
    return 0;
}


//MT1232
//数字和
//请编写一个简单程序，求一个数的各位数字之和。比如输入123，输出1 + 2 + 3的和6.
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int x, sum = 0;
    scanf("%d", &x);
    while (x)
    {
        sum += x % 10;
        x /= 10;
    }
    printf("%d", sum);
    return 0;
}

//MT1233
//数字之和
//求一个自然数n中各位数字之和（n由用户输入）。不考虑负数等特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int n, count = 0, sum = 0;
    scanf("%d", &n);
    int temp = n;
    while (temp)
    {
        temp /= 10;
        count++;
    }
    for (int i = 0; i < count; i++)
    {
        sum += n % 10;
        n /= 10;
    }
    printf("%d", sum);
    return 0;
}

//MT1234
//一个数字
//输入一个非负整数N，重复将其所有数字相加，直到结果只有一个数字，输出这个数字，输出最小列宽3列。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, sum;
    scanf("%d", &N);

    do {
        sum = 0;
        while (N)
        {
            sum += N % 10;
            N /= 10;
        }
        N = sum;
    } while (sum >= 10);
    printf("%3d\n", sum);
    return 0;
}


//MT1235

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    int temp = n, N = 0;
    while (temp)
    {
        N = (N * 10) + (temp % 10);
        temp /= 10;
    }
    if (N == n)
    {
        printf("Y");
    }
    else
    {
        printf("N");
    }
    return 0;
}


//MT1237 六六大顺
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        int temp = i, flag = 0;
        while (temp)
        {
            if (temp % 10 == 6)
            {
                flag = 1;
            }
            temp /= 10;
        }
        if (flag == 1)
        {
            if (i % 6 == 0)
            {
                printf("%d ", i);
            }
        }
    }
    return 0;
}



//MT1238 幸运数字3
#include<stdio.h>
int main()
{
    int N, temp, flag;
    scanf("%d", &N);
    for (int i = 3; i <= N; i++)
    {
        temp = i;
        flag = 0;
        while (temp)
        {
            if (temp % 10 == 3)
            {
                printf("%d ", i);
                flag = 1;
                break;
            }
            temp /= 10;
        }
        if (flag == 0 && i % 3 == 0)
        {
            printf("%d ", i);
        }
    }
    return 0;
}



//MT1239
//自恋性数
//请编写一个简单程序，判断自恋性数。如果一个正整数等于其各个数字的立方和，则称该数为自恋性数(亦称为阿姆斯特朗数)
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出Y或者N

#include<stdio.h>
#include<math.h>
int main()
{
    int x, temp, count = 0;
    scanf("%d", &x);
    temp = x;
    while (temp)
    {
        count += pow(temp % 10, 3);
        temp /= 10;
    }
    if (x == count)
    {
        printf("Y");
    }
    else
    {
        printf("N");
    }
    return 0;
}

//MT1240 好多自恋性数

#include<stdio.h>
#include<math.h>
int main()
{
    int n, temp, num;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        temp = i;
        num = 0;
        while (temp)
        {
            num += pow((double)(temp % 10), 3.0);
            temp /= 10;
        }
        if (num == i)
        {
            printf("%d ", i);
        }
    }
    return 0;
}





//MT1241
//大数
//输入一个数字N，编写一个程序，用该数字的所有数字重组一个最大数字。不考虑负数，0等特殊情况。注意：给定的数字可能非常大，因此输入被视为字符串。
//
//格式
//输入格式：
//输入字符串
//
//输出格式：
//输出字符串


#include<stdio.h>
#include<string.h>
int main()
{
    char a[100];
    scanf("%s", a);
    for (int i = 9; i >= 0; i--)
    {
        for (int j = 0; j < strlen(a); j++)
        {
            if (a[j] == i + '0')
            {
                printf("%c", a[j]);
            }
        }
    }
    return 0;
}




//MT1242
//三个非负整数
//给定一个正整数N，将其分解为3个非负整数的累加和，并统计出这样做的方法数。比如2，有2种分解方法：
//
//0 + 0 + 2 = 2 （0 + 2 + 0 = 2　　2 + 0 + 0 = 2 可以和左边等式看做同一种）
//
//0 + 1 + 1 = 2 （1 + 1 + 0 = 2　　1 + 0 + 1 = 2 可以和左边等式看做同一种）
//
//格式
//输入格式：
//输入整型
//
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, count = 0;
    scanf("%d", &N);
    for (int i = 0; i <= N; i++)
    {
        for (int j = i; j <= N; j++)
        {
            if (N - i - j >= j)
            {
                count++;
            }
        }
    }
    printf("%d", count);
    return 0;
}


//MT1243 四个正整数

#include<stdio.h>
int main()
{
    int N, count = 0;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        for (int j = i; j <= N; j++)
        {
            for (int k = j; k <= N; k++)
            {
                if (N - i - j - k >= k)
                {
                    count++;
                }
            }
        }
    }
    printf("%d", count);
    return 0;
}



//MT1244
//减到0
//输入两个正整数A和B，重复从较大整数中减去较小整数直到其中一个变为0，输出所需的步骤数。比如5和13。(5, 13)->(5, 8)->(5, 3)->(2, 3)->(2, 1)->(1, 1)->(1, 0)一共需要减6次。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int a, b, count = 0;
    scanf("%d %d", &a, &b);
    while (a != 0 && b != 0)
    {
        if (a >= b)
        {
            a = a - b;
        }
        else
        {
            b = b - a;
        }
        count++;
    }
    printf("%d", count);
    return 0;
}


//MT1245 五年花光
#include<stdio.h>
int main()
{
    double n = 0, rate = 12 * 0.00553;
    for (int i = 0; i < 5; i++)
    {
        n = (n + 1000) / (1 + rate);
    }
    printf("%.2lf", n);
    return 0;
}

//MT1246
//存入的钱
//假设银行利息月息为0.63 % 。某人将一笔钱存入银行，打算在今后五年中每年年底都取出1000元，到第五年时刚好取完。求存入的钱应是多少？
//
//格式
//输入格式：
//无
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
int main()
{
    double n = 0;
    for (int i = 1; i <= 5; i++)
    {
        n += 1000;
        n = n / (1 + 12 * 0.0063);
    }
    printf("%.2lf", n);
    return 0;
}

//MT1247
//存10年钱
//银行利息月息为0.58 % 。某人10年中每年年底都取出1000元，到第10年时刚好取完。求存入的钱应是多少？
//
//格式
//输入格式：
//无
//
//输出格式：
//输出实型，保留2位小数。

#include<stdio.h>
int main()
{
    double n = 0;
    for (int i = 1; i <= 10; i++)
    {
        n += 1000;
        n = n / (1 + 12 * 0.0058);
    }
    printf("%.2lf", n);
    return 0;
}

//MT1248 吃桃
#include<stdio.h>
int main()
{
    int n = 1;
    for (int i = 0; i < 9; i++)
    {
        n = (n + 1) * 2;
    }
    printf("%d", n);
    return 0;
}



//MT1249
//练兵
//兽人族的首领很聪明，总是先让士兵3人一排站队，再5人一排重新站队，最后再7人一排，他只用看看队尾人数就知道今天有多少人迟到了。输入3个非负整数a，b，c表示每种队形队尾的人数(a < 3, b < 5, c < 7)，计算总人数，无解则输出 - 1。 总人数在10到100之间。
//
//    格式
//    输入格式：
//    输入整型，空格分隔。
//
//    输出格式：
//    输出整型

#include<stdio.h>
int main()
{
    int x1, x2, x3;
    scanf("%d %d %d", &x1, &x2, &x3);
    for (int i = 10; i <= 100; i++)
    {
        if (i % 3 == x1 && i % 5 == x2 && i % 7 == x3)
        {
            printf("%d", i);
            return 0;
        }
    }
    printf("-1");
    return 0;
}

//MT1250
//阶梯
//科学家出了一道这样的数学题：有一条长阶梯，若每步跨2阶，则最最后剩一阶，若每步跨3 阶，则最后剩2阶，若每步跨5阶，则最后剩4阶，若每步跨6阶则最后剩5阶。只有每次跨7阶，最后才正好一阶不剩。编写程序求这条阶梯共有多少阶？
//
//格式
//输入格式：
//无
//
//输出格式：
//119

#include<stdio.h>
int main()
{
    for (int i = 1; i <= 1000; i++)
    {
        if (i % 2 == 1 && i % 3 == 2 && i % 5 == 4 && i % 6 == 5 && i % 7 == 0)
        {
            printf("%d", i);
            return 0;
        }
    }
    return 0;
}

//MT1251 百钱买百猫
#include<stdio.h>
int main()
{
    for (int i = 0; i <= 20; i++)
    {
        for (int j = 0; j <= 33; j++)
        {
            for (int k = 0; k <= 100; k++)
            {
                if (k % 3 == 0 && i + j + k == 100 && 5 * i + 3 * j + k / 3 == 100)
                {
                    printf("公猫=%d 母猫=%d 小猫=%d\n", i, j, k);
                }
            }
        }
    }
    return 0;
}

//MT1252
//自除数
//自除数是可以被它包含的每一位数除尽的数。例如128，可以被1，2 和8整除。自除数位数中不包含0。输入整数，判断它是不是一个自除数，是就输出YES，否则输出NO。输入不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为YES或者NO

#include<stdio.h>
int main()
{
    int n, x;
    scanf("%d", &n);
    int temp = n;

    while (temp)
    {
        x = temp % 10;
        if (x == 0)
        {
            printf("NO");
            return 0;
        }
        if (n % x != 0)
        {
            printf("NO");
            return 0;
        }
        temp /= 10;
    }
    printf("YES");
    return 0;
}


//MT1253 区间自除数
#include<stdio.h>
int main()
{
    int a, b, temp, flag;
    scanf("%d %d", &a, &b);
    for (int i = a; i <= b; i++)
    {
        temp = i;
        flag = 1;
        while (temp)
        {
            if (temp % 10 == 0 || i % (temp % 10) != 0)
            {
                flag = 0;
                break;
            }
            temp /= 10;
        }
        if (flag == 1)
        {
            printf("%d ", i);
        }
    }
    return 0;
}

//MT1254 最大自除数
// #include<stdio.h>
// int main() 
// { 
//     int a, b, temp, temp2, x, flag, n, m;
//     scanf("%d %d", &a, &b);

//     for (int i=a;i<=b;i++)
//     {
//         if (i >= 10)
//         {
//             temp = i;
//             while (temp)
//             {
//                 n = temp % 10;
//                 temp /= 10;
//                 temp2 = temp;
//                 while (temp2)
//                 {
//                     m = temp2 % 10;
//                     if (n == m)
//                     {
//                         flag = 0;
//                     }
//                 }
//             }
//             if (flag != 0)
//             {
//                 temp = i;
//                 flag = 1;
//                 while (temp)
//                 {
//                     x = temp % 10;
//                     if (x == 0 || i % x != 0)
//                     {
//                         flag = 0;
//                     }
//                     temp /= 10;
//                 }
//                 if (flag == 1)
//                 {
//                     printf("%d", i);
//                     break;
//                 }
//             }
//         }
//     }
//     return 0; 
// }

// #include<stdio.h>
// int main() 
// { 
//     int a, b, temp, flag;
//     scanf("%d %d", &a, &b);

//     for (int i=b;i>=a;i--)
//     {
//         flag = 1;
//         temp = i;
//         while (temp)
//         {
//             if (temp % 10 == 0)
//             {
//                 flag = 0;
//             }
//             else if (i % (temp % 10) != 0)
//             {
//                 flag = 0;
//             }
//             temp /= 10;
//         }
//         if (flag = 1)
//         {
//             printf("%d\n", i);
//             return 0;
//         }
//     }
//     return 0; 
// }


#include<stdio.h>
int main()
{
    int a, b, temp, flag;
    scanf("%d %d", &a, &b);
    for (int i = b; i >= a; i--)
    {
        temp = i;
        flag = 1;
        while (temp)
        {
            if (temp % 10 == 0 || i % (temp % 10) != 0)
            {
                flag = 0;
                break;
            }
            temp /= 10;
        }
        if (flag == 1)
        {
            printf("%d ", i);
            break;
        }
    }
    return 0;
}


//MT1255
//最小自除数
//自除数是可以被它包含的每一位数除尽的数。例如128，因为可以被1，2 和8整除。自除数不包含 0。输入整数区间，输出区间（含边界）内最小自除数。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int a, b, temp, flag;
    scanf("%d %d", &a, &b);
    for (int i = a; i <= b; i++)
    {
        temp = i;
        flag = 1;
        while (temp)
        {
            if (temp % 10 == 0)
            {
                flag = 0;
                break;
            }
            if ((i % (temp % 10)) != 0)
            {
                flag = 0;
            }
            temp /= 10;
        }
        if (flag == 1)
        {
            printf("%d\n", i);
            break;
        }
    }
    return 0;
}

//MT1256
//最小数
//给定两个整数N和M。找出可被M整除的最小数K（大于N），输出K，最小列宽为3。
//
//格式
//输入格式：
//输入正整数N和M
//
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, M;
    scanf("%d %d", &N, &M);
    for (int i = N + 1;; i++)
    {
        if (i % M == 0)
        {
            printf("%3d", i);
            break;
        }
    }
    return 0;
}

//MT1257
//被3整除的五位数
//统计个位是5但能被3整除的五位数有多少个，输出结果。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int x = 3;
    int count = 0;
    for (int i = 10000; i <= 99999; i++)
    {
        if (i % x == 0 && i % 10 == 5)
        {
            count++;
        }
    }
    printf("%d\n", count);
    return 0;
}

//MT1258 特殊整数
#include<stdio.h>
#include<math.h>
int main()
{
    int m, n, temp, flag, count = 0;
    scanf("%d %d", &m, &n);
    int num = pow(10.0, (double)n);
    for (int i = num / 10; i <= num - 1; i++)
    {
        temp = i;
        flag = 0;
        while (temp)
        {
            if (temp % 10 == m)
            {
                flag = 1;
                break;
            }
            temp /= 10;
        }
        if (flag == 1 && i % m != 0)
        {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1259 统计哈沙德数
#include<stdio.h>
int main()
{
    int N, temp, sum, count = 0;
    scanf("%d", &N);
    for (int i = 10; i <= N; i++)
    {
        temp = i;
        sum = 0;
        while (temp)
        {
            sum += temp % 10;
            temp /= 10;
        }
        if (i % sum == 0)
        {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1260
//袋鼠躲猫猫
//两只袋鼠在一个总长L米的圆环上躲猫猫。假定环上某一点为坐标原点0，袋鼠宝宝的出发坐标是x，袋鼠妈妈出发坐标是y，单位是米，宝宝一小时能跳a次，妈妈一小时跳b次，假定他们每一跳的距离都是1米，求多少小时后宝宝和妈妈才能见面。如果无法见面则输出 - 1。x，y，a，b，L都属于正常int范围。“见面”以每小时结束时刻，两只袋鼠的落点相同为准。
//
//格式
//输入格式：
//输入5个正整数x，y，a，b，L，空格分隔。其中x不等于y。
//
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int x, y, a, b, l, time = 1;
    scanf("%d %d %d %d %d", &x, &y, &a, &b, &l);
    if (a == b)
    {
        printf("-1");
        return 0;
    }
    while ((x + a) % l != (y + b) % l)
    {
        x = (x + a) % l;
        y = (y + b) % l;
        time++;
    }
    printf("%d", time);
    return 0;
}


//MT1261 留下来的才是幸运数
#include<stdio.h>
int main()
{
    int N, del = 2;
    scanf("%d", &N);
    while (N >= del)
    {
        if (N % del == 0)
        {
            printf("NO");
            return 0;
        }
        N = N - N / del;
        del++;
    }
    printf("YES");
    return 0;
}


//MT1262
//约数
//计算555555约数中最大的三位数的约数。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int n = 555555;
    for (int i = 999; i >= 100; i--)
    {
        if (n % i == 0)
        {
            printf("%d\n", i);
            return 0;
        }
    }
    return 0;
}

//MT1263
//最大的三位约数
//键盘任意输入一个数n（1000 <= n <= 1000000），编程计算并输出n的所有约数中最大的三位约数。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 999; i >= 100; i--)
    {
        if (n % i == 0)
        {
            printf("%d\n", i);
            return 0;
        }
    }
    return 0;
}


//MT1264
//完数
//如果一个整数等于其所有真因子（即除了自身以外的约数）的和，则该数字称为完数。例如，6 = 1 + 2 + 3，编写一个程序来查找1到1000之间的所有完数。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出为整型，空格分隔

#include<stdio.h>
int main()
{
    int sum = 0;
    for (int i = 1; i <= 1000; i++)
    {
        for (int j = 1; j < i; j++)
        {
            if (i % j == 0)
            {
                sum += j;
            }
        }
        if (sum == i)
        {
            printf("%d ", i);
        }
        sum = 0;
    }
    return 0;
}


//MT1265
//区间完数
//如果一个整数等于其所有真因子之和，则该数字称为完数。例如，6 = 1 + 2 + 3，输入整数区间，输出区间（含边界）内所有的完数。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型，空格分隔

#include<stdio.h>
int main()
{
    int a, b, sum = 0;
    scanf("%d %d", &a, &b);
    for (int i = a; i <= b; i++)
    {
        for (int j = 1; j < i; j++)
        {
            if (i % j == 0)
            {
                sum += j;
            }
        }
        if (sum == i)
        {
            printf("%d ", i);
        }
        sum = 0;
    }
    return 0;
}

//MT1266
//完数与因子
//如果一个整数等于其所有真因子之和，则该数字称为完数。例如，6 = 1 + 2 + 3，按指定格式输出1到1000之间的所有完数他们的真因子。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//无
//
//输出格式：
//分行输出

#include<stdio.h>
int main()
{
    int sum = 0;
    for (int i = 1; i <= 1000; i++)
    {
        for (int j = 1; j < i; j++)
        {
            if (i % j == 0)
            {
                sum += j;
            }
        }
        if (sum == i)
        {
            printf("%d=", i);
            for (int j = 1; j < i; j++)
            {
                if (i % j == 0)
                {
                    if (i / j == 2)
                    {
                        printf("%d", j);
                    }
                    else
                    {
                        printf("%d+", j);
                    }
                }
            }
            printf("\n");
        }
        sum = 0;
    }
    return 0;
}

//MT1267
//亏数
//输入正整数N，如果N的所有因子之和小于两倍的N，该数字则称为亏数。判断N是否为亏数输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出YES或者NO


#include<stdio.h>
int main()
{
    int N, sum = 0;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        if (N % i == 0)
        {
            sum += i;
        }
    }
    if (sum < 2 * N)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1268
//因数的因数
//输入正整数N，任务是求N的所有因数的因数之和。54的因数 = 1，2，3，6，9，18，27，54。
//
//其中1的所有因数之和是1，2的所有因数之和是1 + 2 = 3，依次类推，所有因数的因数之和分别为1, 3, 4, 12, 13, 39, 40, 120。那么54的所有因数的因数之和 = 1 + 3 + 4 + 12 + 13 + 39 + 40 + 120 = 232
//
//格式
//输入格式：
//输入正整数N
//
//输出格式：
//输出整型

#include<stdio.h>
int main()
{
    int N, sum = 0;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        if (N % i == 0)
        {
            for (int j = 1; j <= i; j++)
            {
                if (i % j == 0)
                {
                    sum += j;
                }
            }
        }
    }
    printf("%d\n", sum);
    return 0;
}

//MT1269
//区间素数
//输入整数区间，输出区间（含边界）内所有的素数。如果没有则输出空。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型，空格分隔


#include<stdio.h>
int main()
{
    int a, b, flag = 1;
    scanf("%d %d", &a, &b);
    for (int i = a; i <= b; i++)
    {
        if (i != 1)
        {
            for (int j = 2; j < i; j++)
            {
                if (i % j == 0)
                {
                    flag = 0;
                }
            }
            if (flag == 1)
            {
                printf("%d ", i);
            }
            flag = 1;
        }
    }
    return 0;
}

//MT1270
//素数计算
//编写一个程序来计算m到n之间的素数（含边界）。然后计算总和 = 第一个素数 - 第二个素数 + 第三个素数 - 第四个素数 + 第五个素数…，这些素数按降序排列。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int a, b, flag = 1, sum = 0, num = -1;
    scanf("%d %d", &a, &b);
    for (int i = b; i >= a; i--)
    {
        if (i != 1)
        {
            for (int j = 2; j < i; j++)
            {
                if (i % j == 0)
                {
                    flag = 0;
                }
            }
            if (flag == 1)
            {
                num = -num;
                sum = sum + i * num;
            }
            flag = 1;
        }
    }
    printf("%d\n", sum);
    return 0;
}

//MT1271 三生质数
#include<stdio.h>
#define MAX_NUM 500
int main()
{
    int N, num = 0, flag = 0;
    scanf("%d", &N);
    int Check[MAX_NUM] = { 1, 1 }, primes[MAX_NUM] = { 0 };

    for (int i = 2; i < MAX_NUM; i++)
    {
        if (Check[i] == 0)
        {
            for (int j = 2; j * i < MAX_NUM; j++)
            {
                Check[i * j] = 1;
            }
            primes[num++] = i;
        }
    }

    for (int i = 0; i < num - 2; i++)
    {
        if (primes[i] == primes[i + 1] - 2 && primes[i + 1] == primes[i + 2] - 2)
        {
            flag = 1;
            printf("%d %d %d", primes[i], primes[i + 1], primes[i + 2]);
        }
    }
    if (flag == 0)
    {
        printf("0");
    }
    return 0;
}

//
//MT1272
//双素数
//数学中，两个素数的乘积所得的自然数我们称之为半素数，也叫“双素数”，输入一个正整数，判断他是不是双素数，输出YES或者NO。注意1不是双素数。不考虑0，负数等特殊情况。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出YES或者NO


//#include<stdio.h>
//#include<math.h>
//int main()
//{
//    int N, i, j;
//    scanf("%d", &N);
//    for (i = 2; i < N; i++)
//    {
//        for (j = 2; j < N; j++)
//        {
//            if (N % i == 0 && N % j == 0 && i * j == N)
//            {
//                printf("YES");
//                return 0;
//            }
//        }
//    }
//    printf("NO");
//    return 0;
//}


#include<stdio.h>
int PrimeNumber(int num)
{
    int flag = 1;
    for (int k = 2; k < num; k++)
    {
        if (num % k == 0)
        {
            flag = 0;
        }
    }
    return flag;
}
int main()
{
    int N, i, j;
    scanf("%d", &N);
    for (i = 2; i < N; i++)
    {
        if (PrimeNumber(i))
        {
            for (j = 2; j < N; j++)
            {
                if (PrimeNumber(j))
                {
                    if (N % i == 0 && N % j == 0 && i * j == N)
                    {
                        printf("YES");
                        return 0;
                    }
                }
            }
        }

    }
    printf("NO");
    return 0;
}

//MT1273
//N以内双素数
//数学中, 两个素数的乘积所得的自然数我们称之为半素数，也叫“双素数”，输入一个正整数，输出0到N之间（包括N）所有双素数。注意1不是双素数。不考虑0，负数等特殊情况。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int PrimeNumber(int num)
{
    int flag = 1;
    for (int t = 2; t < num; t++)
    {
        if (num % t == 0)
        {
            flag = 0;
        }
    }
    return flag;
}
int main()
{
    int N;
    scanf("%d", &N);
    for (int i = 2; i <= N; i++)
    {
        for (int j = 2; j < i; j++)
        {
            if (PrimeNumber(j))
            {
                for (int k = 2; k < i; k++)
                {
                    if (PrimeNumber(k))
                    {
                        if (i % k == 0 && i % j == 0 && k * j == i)
                        {
                            printf("%d ", i);
                            goto again;
                        }
                    }
                }
            }
        }
        again:;
    }
    return 0;
}


//MT1274
//都相差6
//请编写一个简单程序，输出5个质数，使相邻的每两个质数都相差6，并把它们按由小到大的顺序排列起来。这样的可能有多组，输出最小的一组。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int main()
{
    int flag;
    for (int i = 2;; i++)
    {
        flag = 1;
        for (int j = i; j <= i + 24; j += 6)
        {
            for (int k = 2; k < j; k++)
            {
                if (j % k == 0)
                {
                    flag = 0;
                    break;
                }
            }
            if (flag == 0)
            {
                break;
            }
        }
        if (flag == 1)
        {
            for (int n = i; n <= i + 24; n += 6)
            {
                printf("%d ", n);
            }
            break;
        }
    }
    return 0;
}

//MT1275
//都相差10
//请编写一个简单程序，由小到大的顺序输出3个相差10的质数。这样的可能有多组，输出最小的一组。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int main()
{
    int flag;
    for (int i = 2;; i++)
    {
        flag = 1;
        for (int j = i; j <= i + 20; j += 10)
        {
            for (int k = 2; k < j; k++)
            {
                if (j % k == 0)
                {
                    flag = 0;
                    break;
                }
            }
            if (flag == 0)
            {
                break;
            }
        }
        if (flag == 1)
        {
            for (int n = i; n <= i + 20; n += 10)
            {
                printf("%d ", n);
            }
            break;
        }
    }
    return 0;
}

//MT1276
//偶数N
//输入偶数N（偶数N大于2），返回两个素数，其和等于偶数N。可能有几种的组合，仅输出最小值所在的组合，按从小到大输出。
//
//格式
//输入格式：
//输入偶数N
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int main()
{
    int N, num, flag = 1;
    scanf("%d", &N);
    for (int i = 2; i < N; i++)
    {
        for (int j = 2; j < i; j++)
        {
            if (i % j == 0)
            {
                flag = 0;
            }
        }
        if (flag == 1)
        {
            num = N - i;
            for (int j = 2; j < num; j++)
            {
                if (num % j == 0)
                {
                    flag = 0;
                }
            }
            if (flag == 1)
            {
                printf("%d %d\n", i, num);
                return 0;
            }
        }
        flag = 1;
    }
    return 0;
}

//MT1277
//合数世纪
//如果一个世纪中的100个年号都不是素数，这个世纪就叫做合数世纪。求第一个合数世纪。从公元0年开始算。
//
//格式
//输入格式：
//无
//
//输出格式：
//输出这个世纪的第一年

#include<stdio.h>
#include<math.h>
int main()
{
    int flag1, flag2;
    for (int i = 0;; i += 100)
    {
        flag2 = 1;
        for (int j = i; j <= i + 100; j++)
        {
            flag1 = 0;
            for (int k = 2; k < sqrt(j); k++)
            {
                if (k == 0 || k == 1)
                {
                    flag1 = 1;
                    break;
                }
                if (j % k == 0)
                {
                    flag1 = 1;
                }
            }
            if (flag1 == 0)
            {
                flag2 = 0;
                break;
            }
        }
        if (flag2 == 1)
        {
            printf("%d", i);
            break;
        }
    }
    return 0;
}

//MT1278
//自然数n的立方
//自然数n的立方等于包含n个连续奇数的序列之和。比如2的立方等于2个连续奇数3、5之和，3的立方等于3个连续奇数7、9、11之和。输入n, 按下面格式输出。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为整型

#include<stdio.h>
#include<math.h>
int main()
{
    int n, cube_n, middle, first;
    scanf("%d", &n);
    int a[n];
    cube_n = pow((double)n, 3.0);
    if (n % 2 == 0)
    {
        middle = cube_n / n;
        first = middle - 1 - (n - 2);
        a[0] = first;
        for (int i = 1; i < n; i++)
        {
            a[i] = a[i - 1] + 2;
        }
    }
    else
    {
        middle = cube_n / n;
        first = middle - (n - 1);
        a[0] = first;
        for (int i = 1; i < n; i++)
        {
            a[i] = a[i - 1] + 2;
        }
    }

    printf("%d*%d*%d=", n, n, n);
    for (int i = 0; i < n; i++)
    {
        if (i == n - 1)
        {
            printf("%d=", a[i]);
        }
        else
        {
            printf("%d+", a[i]);
        }
    }
    printf("%d", cube_n);
    return 0;
}

//MT1279 危险的粒子
#include<stdio.h>
int main()
{
    int t, a = 1, b = 0, temp;
    scanf("%d", &t);
    for (int i = 0; i < t; i++)
    {
        temp = a;
        a = b;
        b = 3 * temp + 2 * b;
    }
    printf("%d %d", a, b);
    return 0;
}


//MT1280
//后2位数
//输入两个整数x和y，计算x的y次方的最后2位数。不考虑负数。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出为整型

#include<stdio.h>
#include<math.h>
int main()
{
    int x, y, num = 1;
    scanf("%d %d", &x, &y);
    for (int i = 0; i < y; i++)
    {
        num *= x;
        num %= 100;
    }
    printf("%d", num);
    return 0;
}

//MT1281 N的M次方
#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    int temp = N, M = 0;
    while (temp)
    {
        M = 10 * M + temp % 10;
        temp /= 10;
    }
    temp = N;
    N = 1;
    for (int i = 1; i <= M; i++)
    {
        N = (N * temp) % 1000;
    }
    printf("%d", N);
    return 0;
}

//MT1282
//Disarium数
//一个自然数，如果每一位数的位数次幂之和等于该自然数，则称之为Disarium数。
//
//比如：89 = 8 + 9 * 9。或者135 = 1 + 3 * 3 + 5 * 5 * 5
//
//输入一个正整数n，检查它是否为Disarium数，是则输出YES否则输出NO。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//输出格式：
//是则输出YES否则输出NO


#include<stdio.h>
#include<math.h>
int main()
{
    int N, count = 0, sum = 0;
    scanf("%d", &N);
    int temp = N;
    while (temp)
    {
        temp /= 10;
        count++;
    }
    temp = N;
    for (int i = count; i > 0; i--)
    {
        sum += pow(temp % 10, (double)i);
        temp /= 10;
    }
    if (sum == N)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}

//MT1283
//区间Disarium数
//一个自然数，如果每一位数的位数次幂之和等于该自然数，则称之为Disarium数。
//
//比如：89 = 8 + 9 * 9。或者135 = 1 + 3 * 3 + 5 * 5 * 5
//
//输入整数区间，输出区间（含边界）内所有的Disarium数。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//
//输出格式：
//输出为整型，空格分隔

#include<stdio.h>
#include<math.h>
int main()
{
    int a, b, temp, count, Disarium;
    scanf("%d %d", &a, &b);
    for (int i = a; i <= b; i++)
    {
        temp = i;
        Disarium = 0;
        count = 0;
        while (temp)
        {
            temp /= 10;
            count++;
        }
        temp = i;
        for (int j = count; j > 0; j--)
        {
            Disarium += pow((double)(temp % 10), (double)j);
            temp /= 10;
        }
        if (Disarium == i)
        {
            printf("%d ", Disarium);
        }
    }
    return 0;
}

//MT1284
//快乐数
//判断一个正整数是否是快乐数字，如果一个数字能够通过有限次快乐变换成为1，则是快乐数字。
//
//快乐变换是对一个数字的每一位的平方数求和。例如：对于68 = 6 * 6 + 8 * 8 = 100，
//
//100 = 1 * 1 + 0 * 0 + 0 * 0 = 1，因此68是快乐数字。输入一个正整数n，检查它是否为快乐数，是则输出YES否则输出NO。不考虑0，负数或者其他特殊情况。
//
//格式
//输入格式：
//输入为整型
//
//
//输出格式：
//是则输出YES，否则输出NO

#include<stdio.h>
#include<math.h>
int main()
{
    int n, temp, sum;
    scanf("%d", &n);
    while (1)
    {
        sum = 0;
        if (n == 1)
        {
            printf("YES");
            break;
        }
        else if (n == 4)
        {
            printf("NO");
            break;
        }
        while (n)
        {
            temp = n % 10;
            n /= 10;
            sum += pow((double)temp, 2.0);
        }
        n = sum;
    }
    return 0;
}

//MT1285
//忠实数
//如果一个数是7的幂，或者能分解成7的不同幂的和，那么这个数就叫做忠实数。 例如49 = 49，8 = 1 + 7， 57 = 1 + 7 + 49。注意1可以看成7的0次方。输入正整数N，判断它是不是忠实数，输出YES或者NO。
//
//格式
//输入格式：
//输入正整数N
//
//
//输出格式：
//输出YES或者NO

#include<stdio.h>
int main()
{
    int N;
    scanf("%d", &N);
    // if (N % 7 == 0 && N != 0)
    // {
    //     printf("YES");
    // }
    // else if (N % 7 == 1)
    // {
    //     printf("YES");
    // }
    // else
    // {
    //     printf("NO");
    // }
    while (N / 7)
    {
        if (N % 7 == 0)
        {
            N /= 7;
        }
        else if (N % 7 == 1)
        {
            N = (N - 1) / 7;
        }
        else
        {
            printf("NO");
            return 0;
        }
    }
    if (N == 1)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}


//MT1286
//忠实数序列
//如果一个数是7的幂，或者能分解成7的不同幂的和，那么这个数就叫做忠实数。 例如49 = 49，8 = 1 + 7， 57 = 1 + 7 + 49。注意1可以看成7的0次方。对忠实数进行从小到大排序得到的序列是1 7 8 49 50…等等。
//
//输入正整数N，找到第N个忠实的数字。
//
//格式
//输入格式：
//输入正整数N(N < 1000)
//
//
//    输出格式：
//    输出整型

#include<stdio.h>
    int main()
{
    int N;
    scanf("%d", &N);
    int i = 0, temp;
    while (N)
    {
        i++;
        temp = i;
        while (temp / 7)
        {
            if (temp % 7 == 0)
            {
                temp /= 7;
            }
            else if (temp % 7 == 1)
            {
                temp = (temp - 1) / 7;
            }
            else
            {
                break;
            }
        }
        if (temp == 1)
        {
            N--;
        }
    }
    printf("%d", i);
    return 0;
}

//MT1287
//ASCII值
//输入一个长度为5的数组，数组元素均在0到9之间，请编写一个函数，把奇数项元素的值加上65，偶数项元素值加上97，把新元素的值看成是ASCII值，依次输出他们对应的字符，空格分隔。
//
//格式
//输入格式：
//输入为整型，空格分隔
//
//输出格式：
//输出字符，空格分隔

#include<stdio.h>
int ASCII(int num, int i)
{
    if (i % 2 == 0)
    {
        num += 97;
    }
    else
    {
        num += 65;
    }
    return num;
}
int main()
{
    int a[5];
    for (int i = 0; i < 5; i++)
    {
        scanf("%d", &a[i]);
    }
    for (int i = 0; i < 5; i++)
    {
        printf("%c ", (char)ASCII(a[i], i));
    }
    return 0;
}


//MT1288 谁在说谎
#include<stdio.h>
int main()
{
    for (int x = 0; x <= 1; x++)
    {
        for (int y = 0; y <= 1; y++)
        {
            for (int z = 0; z <= 1; z++)
            {
                if (((x && !y) || (!x && y)) && ((y && !z) || (!y && z)) && ((z && !x && !y) || (!z && (x + y) != 0)))
                {
                    printf("zs told %s.\n", x ? "the truth" : "a lie");
                    printf("ls told %s.\n", y ? "the truth" : "a lie");
                    printf("ww told %s.\n", z ? "the truth" : "a lie");
                }
            }
        }
    }
    return 0;
}




//MT1289
//调和级数不等式
//有一个调和级数不等式11 < 1 + 1 / 2 + 1 / 3 + … + 1 / m < 12，求满足此不等式的m，m可能有多个，输出最小的一个。
//
//    格式
//    输入格式：
//    无
//
//    输出格式：
//    输出为整型

#include<stdio.h>
int main()
{
    double sum = 0;
    for (int i = 1;; i++)
    {
        sum += (1.0 / (double)i);
        if (sum > 11)
        {
            printf("%d", i);
            return 0;
        }
    }
    return 0;
}


//MT1290
//级数
//编写程序求级数前n项的和，其中n从键盘上输入

//格式
//输入格式：
//输入为整型
//
//输出格式：
//输出为实型

#include<stdio.h>
#include<math.h>
int main()
{
    int n;
    scanf("%d", &n);
    double sum = 0;
    for (int i = 1; i <= n; i++)
    {
        sum += (pow(-1.0, (double)(i - 1)) * pow(2.0, (double)i)) / ((pow(2.0, (double)i) + pow(-1.0, (double)i)) * (pow(2.0, (double)(i + 1)) + pow(-1.0, (double)(i + 1))));
    }
    printf("%lf", sum);
    return 0;
}

//MT1292 某级数
#include<stdio.h>
int main()
{
    int A[100] = { 1, 1 }, S[100] = { 1, 2 };
    for (int i = 2;; i++)
    {
        A[i] = A[i - 2] + 2 * A[i - 1];
        S[i] = S[i - 1] + A[i];
        if (S[i - 1] < 100 && S[i] >= 100)
        {
            printf("%d ", i);
        }
        else if (S[i - 1] < 1000 && S[i] >= 1000)
        {
            printf("%d ", i);
        }
        else if (S[i] >= 10000)
        {
            printf("%d", i);
            break;
        }
    }
    return 0;
}

//MT1293 字母统计
#include<stdio.h>
int main()
{
    char c;
    int count = 0;
    while ((c = getchar()) != '\n')
    {
        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
        {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}

//MT1294
//从指定位置复制
//输入整行字符串（中间可能会有空格），将此字符串从第n个字符（从0开始计数）开始的全部字符复制成为另一个字符串并输出。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//第一行输入字符串，第二行输入n，整型
//
//
//输出格式：
//输出字符串

#include<stdio.h>
#include<string.h>
int main()
{
    char a[100];
    gets(a);
    int n;
    scanf("\n%d", &n);
    for (int i = 0; i < strlen(a); i++)
    {
        if (i >= n)
        {
            printf("%c", a[i]);
        }
    }
    return 0;
}


//MT1297
#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i <= n; i++)
    {
        if (i & 1)
        {
            printf("%d is odd\n", i);
        }
        else
        {
            printf("%d is even\n", i);
        }
    }
    return 0;
}

//MT1298
//小码哥的烦恼
//小码哥抱怨说：“我才发现，C语言里面居然没有二进制的输出格式符，唉，谁能帮我写个函数，实在这个功能啊？”
//
//格式
//输入格式：
//输入一个十进制正整数
//
//输出格式：
//输出对应的二进制

#include<stdio.h>
void Bin(int num)
{
    if (num / 2)
    {
        Bin(num / 2);
    }
    printf("%d", num % 2);
}
int main()
{
    int n;
    scanf("%d", &n);
    Bin(n);
    return 0;
}

//MT1299
//二进制
//输入5个正整数，将他们转换成二进制输出。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//
//输出格式：
//输出整型，每个一行。从低位往高位看，每四位空一位。


#include<stdio.h>
int main()
{
    for (int i = 0; i < 5; i++)
    {
        int n, b[100], count = 0;
        scanf("%d", &n);
        while (n)
        {
            b[count++] = n % 2;
            n /= 2;
        }
        while (count)
        {
            if ((count - 1) % 4 == 0)
            {
                printf("%d ", b[--count]);
            }
            else
            {
                printf("%d", b[--count]);
            }
        }
        printf("\n");
    }
    return 0;
}

//MT1300
#include<stdio.h>
int main()
{
    int n, N[100], count = 0;
    scanf("%d", &n);
    int count1 = 0, count0 = 0;
    while (n)
    {
        N[count++] = n % 2;
        n /= 2;
    }
    for (int i = 0; i <= count; i++)
    {
        if (N[i] == 1)
        {
            count1++;
        }
    }
    if (count1 % 2 == 1)
    {
        printf("ODD");
    }
    else
    {
        printf("EVEN");
    }
    return 0;
}




//MT1302
//二进制转格雷码
//二进制码转换格雷码的方法：从右边第一位起，依次将每一位与左边一位异或（XOR），作为对应格雷码在该位的值，最左边一位不变；比如二进制0010对应的格雷码是0011。
//
//输入一个4位的二进制整数，输出对应的格雷码。
//
//不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入二进制整数
//
//
//输出格式：
//输出二进制整数
#include<stdio.h>
int main()
{
    char a[4];
    scanf("%s", &a);
    for (int i = 3; i > 0; i--)
    {
        if (a[i] != a[i - 1])
        {
            a[i] = '1';
        }
        else
        {
            a[i] = '0';
        }
    }
    printf("%s", a);
    return 0;
}

//MT1303
//格雷码转二进制
//格雷码转换二进制码的方法：从左边第二位起，将每位与左边一位解码后二进制码的值异或，作为该位解码后的值（最左边一位不变）。比如格雷码0011对应的二进制是0010。
//
//输入一个4位的格雷码整数，输出对应的二进制。
//
//不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入二进制整数
//
//
//输出格式：
//输出二进制整数
#include<stdio.h>
int main()
{
    char a[4];
    scanf("%s", &a);
    for (int i = 1; i < 4; i++)
    {
        if (a[i] == a[i - 1])
        {
            a[i] = '0';
        }
        else
        {
            a[i] = '1';
        }
    }
    printf("%s", a);
    return 0;
}

//MT1304
//十进制与格雷码
//给您一个十进制数n（0~7）。您需要找到数字n的格雷码并将其转换为十进制数。假定格雷码为3位，则0~7的格雷码序列是：000，001，011，010，110，111，101，100，可以看出4的格雷码是110，而110对应的十进制数是6，因此G（4） = 6。
//
//不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入整型
//
//
//输出格式：
//输出整型


#include<stdio.h>
int main()
{
    int n, A[4], num = 0, cnt = 3;
    scanf("%d", &n);
    while (n)
    {
        A[cnt--] = n % 2;
        n /= 2;
    }
    for (int i = 3; i >= 2; i--)
    {
        if (A[i] != A[i - 1])
        {
            A[i] = 1;
        }
        else
        {
            A[i] = 0;
        }
    }
    for (int i = 3, k = 1; i >= 1; i--, k = k * 2)
    {
        num += A[i] * k;
    }
    printf("%d", num);
    return 0;
}


//MT1305
//三位数
//一个自然数的七进制表达式是一个三位数，而这个自然数的九进制表示也是一个三位数，且这两个三位数的数码正好相反，编写程序求这个自然数。
//
//格式
//输入格式：
//无
//
//
//输出格式：
//输出为整型

#include<stdio.h>
int main()
{
    int A[3], B[3];
    for (int i = 81; i <= 342; i++)
    {
        int temp1 = i, temp2 = i;
        for (int j = 2; j >= 0; j--)
        {
            A[j] = temp1 % 7;
            temp1 /= 7;
        }
        for (int j = 2; j >= 0; j--)
        {
            B[j] = temp2 % 9;
            temp2 /= 9;
        }
        if (A[0] == B[2] && A[1] == B[1] && A[2] == B[0])
        {
            printf("%d", i);
            break;
        }
    }
    return 0;
}


//MT1306 牛顿迭代法
#include<stdio.h>
#include<stdlib.h>
double f(double x)
{
    return 2 * x * x * x + 4 * x * x - 7 * x - 6;
}
double fdao(double x)
{
    return 6 * x * x + 8 * x - 7;
}
int main()
{
    double x0 = 1.5;
    double x1 = x0 - f(x0) / fdao(x0);
    while (fabs(x1 - x0) > 1e-6)
    {
        x0 = x1;
        x1 = x0 - f(x0) / fdao(x0);
    }
    printf("%lf", x1);
    return 0;
}

//MT1307
//对分法
//用对分法求方程x* x−6* x - 1 = 0在区间[-10, 0]上的实根。
//
//格式
//输入格式：
//无
//
//
//输出格式：
//输出为实型

#include<stdio.h>
#include<stdlib.h>
double f(double x)
{
    return x * x - 6 * x - 1;
}
int main()
{
    double a = -10, b = 0;
    double mid = (a + b) / 2;
    while (fabs(f(mid)) > 1e-6)
    {
        mid = (a + b) / 2;
        if (f(mid) * f(a) > 0)
        {
            a = mid;
        }
        else
        {
            b = mid;
        }
    }
    printf("%lf", mid);
    return 0;
}


//MT1308
//4个自然数
//求4个自然数p, q, r, s(p≤q≤r≤s)，使得等式1 / p + 1 / q + 1 / r + 1 / s = 1成立。
//
//格式
//输入格式：
//无
//
//
//输出格式：
//输出为整型，空格分隔，每组一行
#include<stdio.h>
int main()
{
    int p, q, r, s;
    for (p = 2; p <= 4; p++)
    {
        for (q = p; q <= 6; q++)
        {
            for (r = q; r <= 12; r++)
            {
                int fenmu = p * q * r - p * q - q * r - r * p, fenzi = p * q * r;
                if (fenmu)
                {
                    if ((fenzi % fenmu == 0) && (fenzi / fenmu >= r))
                    {
                        printf("%d %d %d %d\n", p, q, r, fenzi / fenmu);
                    }
                }
            }
        }
    }
    return 0;
}

















//MT1311
//组数
//用0 : 9可以组成多少无重复的3位数。
//
//格式
//输入格式：
//无
//
//
//输出格式：
//输出为整型
#include<stdio.h>
int main()
{
    int count = 0;
    for (int i = 1; i <= 9; i++)
    {
        for (int j = 0; j <= 9; j++)
        {
            for (int k = 0; k <= 9; k++)
            {
                if (i != j && j != k && i != k)
                {
                    count++;
                }
            }
        }
    }
    printf("%d\n", count);
    return 0;
}

//MT1312
//给定的商
//输入一个给定的商（商 < 80），商为正整数。求出对应的被除数(5位数)和除数(4位数)。要求被除数和除数每个位置上（个位，十位…）的数字只能出现一次。
//
//    注：只使用1到9的9个数字
//
//    格式
//    输入格式：
//    输入整型
//
//
//    输出格式：
//    输出整型，空格分隔。每组一行。如果没有匹配的结果，则不输出。

#include<stdio.h>
int judge(int a, int b)
{
    int g[10] = { 0 };
    int f = a * 100000 + b;
    for (int i = 1; i <= 10; i++)
    {
        if (g[f % 10] == 0)
        {
            g[f % 10] = 1;
        }
        else
        {
            return 0;
        }
        f /= 10;
    }
    return 1;
}
int main()
{
    int a;
    scanf("%d", &a);
    for (int i = 1000; i <= 9999; i++)
    {
        if (i * a >= 10000 && i * a <= 99999)
        {
            if (judge(i, i * a))
            {
                printf("%d %d\n", i * a, i);
            }
        }
    }
    return 0;
}

//MT1313 1比2比3
#include<stdio.h>
int judge(int a, int b, int c)
{
    int g[10] = { 0 };
    int num = a * 1000000 + b * 1000 + c;
    for (int i = 1; i <= 10; i++)
    {
        if (g[num % 10] == 0)
        {
            g[num % 10] = 1;
        }
        else
        {
            return 0;
        }
        num /= 10;
    }
    return 1;
}
int main()
{
    for (int i = 100; i <= 999; i++)
    {
        if (2 * i < 1000 && 3 * i < 1000)
        {
            if (judge(i, 2 * i, 3 * i))
            {
                printf("%d:%d:%d=1:2:3\n", i, 2 * i, 3 * i);
            }
        }
    }
    return 0;
}




//MT1328
//用函数求和
//定义一个函数int add(int x, int y) ，在主函数中输入两个整数a，b，调用add函数求a，b的和，再在主函数中输出和。
//
//格式
//输入格式：
//输入两个整数a, b，逗号分隔
//
//输出格式：
//输出和，整型


#include<stdio.h>
int add(int x, int y)
{
    return x + y;
}
int main()
{
    int a, b;
    scanf("%d,%d", &a, &b);
    printf("%d\n", add(a, b));
    return 0;
}

//MT1329
//用函数计算公式
//编写函数fun, 求1＋4＋7＋10＋…..n的和。主函数中输入正整数n，输出累加和。比如输入7，则求1＋4＋7的和，如果输入5，则求1＋4的和。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型


#include<stdio.h>
int func(int n)
{
    int i, sum = 0;
    for (i = 1; i <= n; i)
    {
        sum += i;
        i += 3;
    }
    return sum;
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", func(n));
    return 0;
}

//MT1330 区间数字总和
#include<stdio.h>
int main()
{
    int a, b, c, d, e, f;
    scanf("%d %d %d %d %d %d", &a, &b, &c, &d, &e, &f);
    int sum = 0;
    for (int i = a; i <= b; i++)
    {
        sum += i;
    }
    for (int i = c; i <= d; i++)
    {
        sum += i;
    }
    for (int i = e; i <= f; i++)
    {
        sum += i;
    }
    printf("%d", sum);
    return 0;
}


//MT1331 用函数求π的近似值
#include<stdio.h>
double Fun()
{
    double sum = 0, num = 1;
    for (double i = 1;; i += 2)
    {
        sum += (1.0 / i * num);
        num = -num;
        if ((1.0 / i) < 0.000001)
        {
            return 4 * sum;
        }
    }
}
int main()
{
    printf("%.2lf", Fun());
    return 0;
}


//MT1332
//用函数求最大值
//定义一个函数 ，在主函数中输入4个整数 ，调用函数求最大值，再在主函数中输出。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型


#include<stdio.h>
int max(int a, int b, int c, int d)
{
    int max1, max2;
    if (a > b)
    {
        max1 = a;
    }
    else
    {
        max1 = b;
    }
    if (c > d)
    {
        max2 = c;
    }
    else
    {
        max2 = d;
    }
    if (max1 > max2)
    {
        return max1;
    }
    else
    {
        return max2;
    }
}
int main()
{
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    printf("%d\n", max(a, b, c, d));
    return 0;
}


//MT1333
//用函数求最小值
//定义一个函数 ，在主函数中输入4个整数 ，调用函数求最小值，再在主函数中输出。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型



#include<stdio.h>
int min(int a, int b, int c, int d)
{
    int min1, min2;
    if (a < b)
    {
        min1 = a;
    }
    else
    {
        min1 = b;
    }
    if (c < d)
    {
        min2 = c;
    }
    else
    {
        min2 = d;
    }
    if (min1 < min2)
    {
        return min1;
    }
    else
    {
        return min2;
    }
}
int main()
{
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    printf("%d\n", min(a, b, c, d));
    return 0;
}



//MT1334
//最小整数
//编写函数getceil(x)，返回大于等于x的最小整数，例如getceil(2.8)为3，getceil(-2.8)为 - 2。
//
//格式
//输入格式：
//输入为实型
//
//输出格式：
//输出为整型


#include<stdio.h>
//正、负实数强制转换成整数后，被截断。例如，（2.3）--》（2），（-1.2）--》（-1）
int getceil(double x)
{
    if (x > 0)
    {
        if (x - (int)x > 0)
        {
            return (int)x + 1;
        }
        else
        {
            return (int)x;
        }
    }
    else
    {
        return (int)x;
    }
}
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%d\n", getceil(x));
    return 0;
}



//MT1335
//最大整数
//编写函数getfloor(x)，返回小于等于x的最大整数，例如getfloor(2.8)为2，getfloor(-2.8)为 - 3。
//
//格式
//输入格式：
//输入为实型
//
//输出格式：
//输出为整型



#include<stdio.h>
int getfloor(double x)
{
    if (x > 0)
    {
        return (int)x;
    }
    else
    {
        if (x - (int)x < 0)
        {
            return (int)x - 1;
        }
        else
        {
            return (int)x;
        }
    }
}
int main()
{
    double x;
    scanf("%lf", &x);
    printf("%d\n", getfloor(x));
    return 0;
}

//MT1336
//用函数求阶乘
//定义一个函数int fact(int x) ，在主函数中输入正整数a，调用fact函数求a的阶乘，再在主函数中输出阶乘
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型


#include<stdio.h>
int fact(int x)
{
    int i, sum = 1;
    for (i = 1; i <= x; i++)
    {
        sum *= i;
    }
    return sum;
}
int main()
{
    int x;
    scanf("%d", &x);
    printf("%d", fact(x));
    return 0;
}

//MT1337
//n次方
//编写函数fun，求任一整数m的n次方（n为非负数）。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型


#include<stdio.h>
int fun(int m, int n)
{
    int i, result = 1;
    for (i = 0; i < n; i++)
    {
        result *= m;
    }
    return result;
}
int main()
{
    int m, n;
    scanf("%d %d", &m, &n);
    printf("%d\n", fun(m, n));
    return 0;
}

//MT1338
//开n次方
//编写函数计算x开n次方的正实根S(x, n)，在主函数中输入数据调用函数输出结果。不考虑不合理输入等特殊情况。本题使用二分法。
//
//格式
//输入格式：
//输入x为实型，n为整数，空格分隔。前面是x，后面是n。
//
//输出格式：
//输出为实型

#include<stdio.h>
#include<math.h>
int main()
{
    double x, n;
    scanf("%lf %lf", &x, &n);
    printf("%lf\n", pow(x, 1.0 / n));
    return 0;
}

//MT1339
//平均数
//编写函数计算：
//�
//=
//∑
//�
//=
//1
//�
//(
//    �
//    �
//    −
//    �
//    ˉ
//)
//2
//，其中
//�
//ˉ
//为
//�
//1
//,
//�
//2
//,
//…
//…
//的平均数
//s = ∑
//i = 1
//n
//​
//(x
//    i
//    ​
//    −
//    x
//    ˉ
//)
//2
//，其中
//x
//ˉ
//为x
//1
//​
//, x
//2
//​
//, ……的平均数
//
//格式
//输入格式：
//输入为实型，第一行输入n，第二行输入n个数，空格分隔
//
//输出格式：
//输出为实型

#include<stdio.h>
#include<math.h>
double Calculate(int n, double a[])
{
    double ave = 0, s = 0;
    for (int j = 0; j < n; j++)
    {
        ave += a[j];
    }
    ave = ave / n;
    for (int j = 0; j < n; j++)
    {
        s += pow(a[j] - ave, 2.0);
    }
    return s;
}
int main()
{
    int n;
    scanf("%d", &n);
    double a[n];
    for (int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    printf("%lf\n", Calculate(n, a));
    return 0;
}

//MT1340
//平均值函数
//有一个一维数组，含N个整型元素，编写一个函数double avg(int arr[], int begin, int end)，求解从起始位置下标begin到结束位置下标end的所有元素的平均值。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//第一行输入数组长度N，起始位置下标begin，结束位置下标end，第二行输入数组元素，整型，空格分隔。
//
//输出格式：
//输出实型

#include<stdio.h>
double avg(int arr[], int begin, int end)
{
    double sum = 0;
    for (int i = begin; i <= end; i++)
    {
        sum += arr[i];
    }
    return (sum / (double)(end + 1 - begin));
}
int main()
{
    int N, begin, end;
    scanf("%d %d %d", &N, &begin, &end);
    int arr[N];
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("%lf", avg(arr, begin, end));
    return 0;
}

//MT1341 反比例函数
#include<stdio.h>
double f(double x)
{
    return 1.0 / x;
}
int main()
{
    double a, b;
    scanf("%lf %lf", &a, &b);
    double h = (b - a) / 1000.0;
    double x1 = a, x2 = a + h, ans = 0;
    for (int i = 0; i < 1000; i++)
    {
        ans += (f(x1) + f(x2)) * h / 2.0;
        x1 += h;
        x2 += h;
    }
    printf("%.2lf", ans);
    return 0;
}



//MT1342 函数积分
#include<stdio.h>
double f(double x)
{
    return 1.0 / (x + 1);
}
int main()
{
    double a, b;
    scanf("%lf %lf", &a, &b);
    double h = 0.001;
    double x1 = a, x2 = a + h, ans = 0;
    for (int i = 0; i < (b - a) / 0.001; i++)
    {
        ans += (f(x1) + f(x2)) * h / 2.0;
        x1 += h;
        x2 += h;
    }
    printf("%lf", ans);
    return 0;
}


//MT1343 积分
#include<stdio.h>
double f(double x)
{
    return 1.0 / (1 + x * x);
}
int main()
{
    double a, b;
    scanf("%lf %lf", &a, &b);
    double h = 0.001, x1 = a, x2 = a + h, ans = 0;
    for (int i = 0; i < (b - a) / 0.001; i++)
    {
        ans += (f(x1) + f(x2)) * h / 2;
        x1 += h;
        x2 += h;
    }
    printf("%lf", ans);
    return 0;
}


//MT1344 组合
#include<stdio.h>
int f(int x)
{
    int num = 1;
    for (int i = 1; i <= x; i++)
    {
        num *= i;
    }
    return num;
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    int A, C;
    A = f(n) / f(n - m);
    C = A / f(m);
    printf("%d", C);
    return 0;
}


//MT1345
//分段函数
//编写函数求Y的值，当输入X大于等于0时，Y的值是X开2次方，当X小于0时，Y = X + 33。在主函数中输入X，调用函数输出Y。
//
//格式
//输入格式：
//输入为实型。
//
//输出格式：
//输出为实型。

#include<stdio.h>
#include<math.h>
double Function(double X)
{
    if (X >= 0)
    {
        return sqrt(X);
    }
    else
    {
        return X + 33;
    }
}
int main()
{
    double X;
    scanf("%lf", &X);
    printf("%lf\n", Function(X));
    return 0;
}

//
//MT1347
//数组计算
//有两个数组A和B，他们都有N(< 100)个非0整数元素，编写4个函数，分别实现他们的“加减乘除”运算，即根据输入的运算符把对应元素做加减乘除运算，结果放在C数组的对应位置，输出C数组。
//
//    格式
//    输入格式：
//    第一行输入数组长度N，后两行分别输入A，B数组的元素，整型，空格分隔。最后一行输入运算符。
//
//
//    输出格式：
//    输出整型，空格分隔。

#include<stdio.h>
void Add(int a[], int b[], int c[], int N)
{
    for (int j = 0; j < N; j++)
    {
        c[j] = a[j] + b[j];
    }
}
void Sub(int a[], int b[], int c[], int N)
{
    for (int j = 0; j < N; j++)
    {
        c[j] = a[j] - b[j];
    }
}
void Mul(int a[], int b[], int c[], int N)
{
    for (int j = 0; j < N; j++)
    {
        c[j] = a[j] * b[j];
    }
}
void Div(int a[], int b[], int c[], int N)
{
    for (int j = 0; j < N; j++)
    {
        c[j] = a[j] / b[j];
    }
}
int main()
{
    int N;
    scanf("%d\n", &N);
    int a[100], b[100], c[100] = { 0 };
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &b[i]);
    }
    char op;
    scanf("\n%c", &op);

    if (op == '+')
    {
        Add(a, b, c, N);
    }
    else if (op == '-')
    {
        Sub(a, b, c, N);
    }
    else if (op == '*')
    {
        Mul(a, b, c, N);
    }
    else if (op == '/')
    {
        Div(a, b, c, N);
    }

    for (int i = 0; i < N; i++)
    {
        printf("%d ", c[i]);
    }
    return 0;
}


//MT1348
//方程系数
//输入正整数a和b，编写一个函数，求满足方程ax–by = 0中的x和y的最小值并输出，其中x > 0、y > 0、a > 0和b > 0。
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//输出整型，空格分隔。

#include<stdio.h>
int Function(int a, int b)
{
    if (a >= b)
    {
        for (int i = b; i > 0; i--)
        {
            if (b % i == 0 && a % i == 0)
            {
                return i;
            }
        }
    }
    else
    {
        for (int i = a; i > 0; i--)
        {
            if (b % i == 0 && a % i == 0)
            {
                return i;
            }
        }
    }
}
int main()
{
    int a, b, CommonDivisor;
    scanf("%d %d", &a, &b);
    CommonDivisor = Function(a, b);
    printf("%d %d", b / CommonDivisor, a / CommonDivisor);
    return 0;
}


//MT1349
//欧几里德算法
//编写函数int gcd(int a, int b)，使用欧几里德算法，给定a和b计算最大公约数输出。不考虑溢出等特殊情况。
//
//格式
//输入格式：
//输入正整数a和b，空格分隔。
//
//
//输出格式：
//输出整型，空格分隔。


#include<stdio.h>
int gcd(int a, int b)
{
    // int min, n;
    // if (a > b)
    // {
    //     min = b;
    //     n = a % b;
    //     while (n)
    //     {
    //         int temp = n;
    //         n = min % n;
    //         min = temp;
    //     }
    //     return min;
    // }
    // else
    // {
    //     min = a;
    //     n = b % a;
    //     while (n)
    //     {
    //         int temp = n;
    //         n = min % n;
    //         min = temp;
    //     }
    //     return min;
    // }
    int temp;
    while (a % b)
    {
        temp = b;
        b = a % b;
        a = temp;
    }
    return b;

}
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d", gcd(a, b));
    return 0;
}


//MT1351 用函数判断素数
#include<stdio.h>
char fun(int n)
{
    if (n < 2)
    {
        return 'N';
    }
    for (int i = 2; i < n; i++)
    {
        if (n % i == 0)
        {
            return 'N';
        }
    }
    return 'Y';
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%c", fun(n));
    return 0;
}



//MT1353
//找零
//人民币面值有1、2、5、10、20、50元。编写函数change(m, c)；其中m为商品价格，c为顾客付款。函数输出应给顾客找零的各种面值人民币的总张数，且总数之和最少。
//
//不考虑负数或者其他非法输入等特殊情况。
//
//格式
//输入格式：
//输入商品价格，顾客付款，均为整型，单位为元，空格分隔。
//
//
//输出格式：
//输出为整型

#include<stdio.h>
int change(int m, int c)
{
    int count = 0, n = 0;
    int remainder = c - m;
    while (remainder)
    {
        if (remainder / 50 >= 1)
        {
            n = remainder / 50;
            remainder = remainder % 50;
            count += n;
        }
        else if (remainder / 20 >= 1)
        {
            n = remainder / 20;
            remainder = remainder % 20;
            count += n;
        }
        else if (remainder / 10 >= 1)
        {
            n = remainder / 10;
            remainder = remainder % 10;
            count += n;
        }
        else if (remainder / 5 >= 1)
        {
            n = remainder / 5;
            remainder = remainder % 5;
            count += n;
        }
        else if (remainder / 2 >= 1)
        {
            n = remainder / 2;
            remainder = remainder % 2;
            count += n;
        }
        else
        {
            n = remainder;
            count += n;
        }
    }
    return count;
}
int main()
{
    int m, c;
    scanf("%d %d", &m, &c);
    printf("%d\n", change(m, c));
    return 0;
}








//MT1366
//用函数求平方和
//编写函数fun, 求 1 * 1 + 2 * 2 + 3 * 3 + …… + n * n的和。主函数中输入正整数n，输出累加和
//
//格式
//输入格式：
//输入整型
//
//
//输出格式：
//输出整型
#include<stdio.h>
int fun(int n)
{
    int sum = 0;
    for (int i = 1; i <= n; i++)
    {
        sum += i * i;
    }
    return sum;
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", fun(n));
    return 0;
}

//MT1367
//求解函数
//已知ack函数对于m≥0和n≥0有定义：ack(0, n) = n + 1、ack(m, 0) = ack(m - 1, 1)、ack(m, n) = ack(m - 1, ack(m, n - 1))。
//
//输入m和n，求解ack函数。（本题中m和n不同时为0）
//
//格式
//输入格式：
//输入为正整数，空格分隔
//
//
//输出格式：
//输出为整型
#include<stdio.h>
int ack(int m, int n)
{
    if (m == 0)
    {
        return n + 1;
    }
    else if (n == 0)
    {
        return ack(m - 1, 1);
    }
    else
    {
        return ack(m - 1, ack(m, n - 1));
    }
}
int main()
{
    int m, n;
    scanf("%d %d", &m, &n);
    printf("%d\n", ack(m, n));
    return 0;
}

//MT1368
//递归法求逆序
//用递归法求解：将一个四位数（如5678）逆序（如8765）。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入大于0的4位正整数
//
//
//输出格式：
//输出为整型

#include<stdio.h>
void fun(int n, int count)
{
    int num = 1;
    for (int i = 0; i < count; i++)
    {
        num *= 10;
    }
    if (n / 10)
    {
        fun(n % num, count - 1);
    }
    printf("%d", n / num);

}
int main()
{
    int n, count = 4;
    scanf("%d", &n);
    fun(n, count - 1);
    return 0;
}





//MT1370
//递归函数
//输入正整数N，递归地对N的位数求和，直到得到一个位数并输出。
//
//格式
//输入格式：
//输入正整数N
//
//
//输出格式：
//输出整型
#include<stdio.h>
int fun(int n)
{
    int sum = 0;
    if (n / 10 != 0)
    {
        while (n)
        {
            sum += n % 10;
            n /= 10;
        }
        return fun(sum);
    }
    else
    {
        return n;
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", fun(n));
    return 0;
}


//MT1372 矩阵清零
#include<stdio.h>
// void Replace(int N, int a[][N - 1])
// {
//     for (int i=0;i<N;i++)
//     {
//         for (int j=0;j<N;j++)
//         {
//             a[i][j] = 0;
//             printf("%d ", a[i][j]);
//         }
//         printf("\n");
//     }
// }
void fun(int N)
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            printf("0 ");
        }
        printf("\n");
    }
}
int main()
{
    int N;
    scanf("%d", &N);
    fun(N);
    // int a[N - 1][N - 1];
    // for (int i=0;i<N;i++)
    // {
    //     for (int j=0;j<N;j++)
    //     {
    //         scanf("%d", &a[i][j]);   
    //     }
    // }
    // Replace(N, a);
    return 0;
}



//MT1373 亲和数
#include<stdio.h>
int main()
{
    int A, B, sum = 0;
    scanf("%d %d", &A, &B);
    for (int i = 1; i < A; i++)
    {
        if (A % i == 0)
        {
            sum += i;
        }
    }
    if (B == sum)
    {
        sum = 0;
        for (int i = 1; i < B; i++)
        {
            if (B % i == 0)
            {
                sum += i;
            }
        }
        if (A == sum)
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
    else
    {
        printf("NO");
    }
    return 0;
}


#include<stdio.h>
int judge(int A, int B)
{
    int sum = 0;
    for (int i = 1; i < A; i++)
    {
        if (A % i == 0)
        {
            sum += i;
        }
    }
    if (B == sum)
    {
        sum = 0;
        for (int i = 1; i < B; i++)
        {
            if (B % i == 0)
            {
                sum += i;
            }
        }
        if (A == sum)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    else
    {
        return 0;
    }
}
int main()
{
    int A, B;
    scanf("%d %d", &A, &B);
    if (judge(A, B))
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    return 0;
}







//MT1374
//Pronic数
//请编写一个函数求m至n之间的所有Pronic数字，如果某个数字是两个连续数字的乘积, 则该数字被称为Pronic数。比如6 = 2 x 3，72 = 8 x 9。
//
//输入整数区间，输出区间（含边界）内所有的Pronic数。在主函数中输入m和n，调用函数int PronicNumber(int x)进行判断，再在主函数中输出结果。
//
//不考虑不合理的输入或是溢出等特殊情况。
//
//格式
//输入格式：
//输入为正整数，空格分隔
//
//
//输出格式：
//输出为整型，空格分隔
#include<stdio.h>
int PronicNumber(int x)
{
    int flag = 0;
    for (int i = 1, j = 2; j <= x; i++, j++)
    {
        if (i * j == x)
        {
            flag = 1;
            return flag;
        }
    }
    return flag;
}
int main()
{
    int m, n;
    scanf("%d %d", &m, &n);
    for (int i = m; i <= n; i++)
    {
        if (PronicNumber(i) == 1)
        {
            printf("%d ", i);
        }
    }
    return 0;
}



//MT1376 小码哥的数学
int fun(int a, int b)
{
    int sum = a + b;
    b = sum % 10;
    sum /= 10;
    a = sum % 10;
    return a * 10 + b;
    // return sum % 100;
}
int main()
{
    int N, a, b;
    scanf("%d\n", &N);
    for (int i = 0; i < N; i++)
    {
        scanf("%d %d", &a, &b);
        printf("%d\n", fun(a, b));
    }
    return 0;
}


//MT1377
//模乘逆元
//给定两个正整数a和m。编写一个函数，找到模’m’下’a’的最小模乘逆元b。模乘逆元定义：满足 a* b≡1（mod m)，称b为a模乘逆元（b < m）。
//
//    注：x = n(mod m)意思是x除以m的余数是n。
//
//    格式
//    输入格式：
//    输入正整数a和m，空格分隔。
//
//
//    输出格式：
//    输出整型

#include<stdio.h>
int fun(int a, int m)
{
    for (int i = 1; i < m; i++)
    {
        if (a * i % m == 1)
        {
            return i;
        }
    }
    return -1;
}
int main()
{
    int a, m;
    scanf("%d %d", &a, &m);
    printf("%d\n", fun(a, m));
    return 0;
}




//MT1379
//operate函数
//编写函数operate(int a, int b, char op)。每次调用operate函数时可以实现不同的功能，如计算a和b的和、差。
//
//格式
//输入格式：
//输入a，op ，b，其中a、b为整型，op为 + 或者 - 。
//
//
//输出格式：
//输出整型
#include<stdio.h>
int operate(int a, int b, char op)
{
    if (op == '+')
    {
        return a + b;
    }
    else
    {
        return a - b;
    }
}
int main()
{
    int a, b;
    char op;
    scanf("%d%c%d", &a, &op, &b);
    printf("%d", operate(a, b, op));
    return 0;
}


//MT1380
//mymath函数
//编写函数mymath(int a, int b, char op)。每次调用mymath函数时可以实现不同的功能，如a和b的乘、除、求余计算。不考虑不合理的输入等特殊情况。
//
//格式
//输入格式：
//输入a，op ，b，其中a、b为整型，op为* ， / 或者 % 。
//
//
//输出格式：
//除法输出实型，乘法和求余输出整型


#include<stdio.h>
double mymath(int a, int b, char op)
{
    if (op == '*')
    {
        printf("%d", a * b);
    }
    else if (op == '/')
    {
        printf("%lf", (double)a / (double)b);
    }
    else
    {
        printf("%d", a % b);
    }
}
int main()
{
    int a, b;
    char op;
    scanf("%d%c%d", &a, &op, &b);
    mymath(a, b, op);
    return 0;
}

//MT1381
//逆序输出数组
//定义一个长度为10的整型数组，输入10个数组元素的值，然后逆序输出他们
//
//格式
//输入格式：
//输入10个数组元素的值，整型，空格分隔
//
//输出格式：
//逆序输出10个数组元素的值，整型，空格分隔



#include<stdio.h>
#define N 10
int main()
{
    int i, a[N];
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = N - 1; i >= 0; i--)
    {
        printf("%d ", a[i]);
    }
    return 0;
}


//MT1382
//奇数项
//定义一个长度为10的整型数组，输入10个数组元素的值，然后输出奇数项。
//
//格式
//输入格式：
//输入10个数组元素的值，整型，空格分隔
//
//输出格式：
//输出数组奇数项，整型，空格分隔




#include<stdio.h>
#define N 10
int main()
{
    int i, a[N];
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 1; i < N; i)
    {
        printf("%d ", a[i]);
        i += 2;
    }
    return 0;
}


//MT1383 偶数项和偶数值
#include<stdio.h>
#define N 10
int main()
{
    int a[N];
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (int i = 0; i < N; i++)
    {
        if (i % 2 == 0 && a[i] % 2 == 0)
        {
            printf("%d ", a[i]);
        }
    }
    return 0;
}

//
//MT1384 李代桃僵
#include<stdio.h>
#define N 10
int main()
{
    int a[N], n, m;
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    scanf("%d %d", &n, &m);
    for (int i = 0; i < N; i++)
    {
        if (a[i] == n)
        {
            a[i] = m;
        }
    }
    for (int i = 0; i < N; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}




//MT1385
//查找
//在一组给定的数据中，找出某个数据是否存在。定义长度为10的数组，输入数组元素，和要查找的数据，如果找到输出下标。没找到则输出No。
//
//格式
//输入格式：
//第1行输入数组元素，空格分隔
//
//第2行输入要查找的整数n
//
//输出格式：
//输出整型



#include<stdio.h>
#define N 10
int main()
{
    int a[N], i, n;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    scanf("%d", &n);
    for (i = 0; i < N; i++)
    {
        if (a[i] == n)
        {
            printf("%d\n", i);
            break;
        }
        else
        {
            if (i == N - 1)
            {
                printf("No");
            }
        }
    }
    return 0;
}




//MT1386
//第n个数
//编写程序读入n（n < 200）个整数（输入 - 9999结束）。找出第1到第n－1个数中第1个与第n个数相等的那个数，并输出该数的序号（序号从1开始）。如果没有，则输出”no such number”。
//
//格式
//输入格式：
//输入为整型，空格分隔。
//
//输出格式：
//输出为整型




//#include<stdio.h>
//#define N 200
//int main()
//{
//    int a[N], i = -1, n = 0;
//    do
//    {
//        i += 1;
//        scanf("%d", &a[i]);
//    } while (a[i] == -9999);
//    while (n > i - 1)
//    {
//        if (a[n] == a[i - 1])
//        {
//            printf("%d\n", n + 1);
//            break;
//        }
//        else
//        {
//            if (n == i - 1)
//            {
//                printf("no such number");
//            }
//            else
//            {
//                n++;
//            }
//        }
//    }
//    return 0;
//}
#include<stdio.h>
#define N 200
int main()
{
    int a[N], i, n = 0;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 0; i < N; i++)
    {
        if (a[i] == -9999)
        {
            break;
        }
    }
    for (n = 0; n < i; n++)
    {
        if (a[n] == a[i - 1])
        {
            if (n == i - 1)
            {
                printf("no such number\n");
            }
            else
            {
                printf("%d\n", n + 1);
                break;
            }
        }
    }
    return 0;
}



//MT1387
//删除指定元素
//定义一个长度为n的整型数组，输入n个数组元素的值，然后输入要删除的数编号，比如删掉从左向右第5个数，输出删除后的数组。
//
//格式
//输入格式：
//输入整型，分3行输入。第一行输入n，第二行输入n个数组元素的值，空格分隔，第三行输入编号
//
//输出格式：
//输出整型，空格分隔




#include<stdio.h>
int main()
{
    int n, i, K;
    scanf("%d", &n);
    int a[n];
    for (i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    scanf("%d", &K);
    for (i = 0; i < n; i++)
    {
        if (i >= K - 1)
        {
            if (i != n - 1)
            {
                a[i] = a[i + 1];
            }
            else
            {
                a[i] = 0;
            }
        }
    }
    for (i = 0; i < n - 1; i++)
    {
        printf("%d ", a[i]);
    }

    return 0;
}


//MT1393
//重复元素
//请编写一个简单程序，输入10个整型元素，依次输出重复元素。
//
//格式
//输入格式：
//输入整型元素，空格分隔。
//
//输出格式：
//输出整型，空格分隔。


#include<stdio.h>
#define N 10
int main()
{
    int a[N], i, j;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 0; i < N; i++)
    {
        for (j = i + 1; j < N; j++)
        {
            if (a[i] == a[j])
            {
                printf("%d ", a[i]);
            }
        }
    }
    return 0;
}


//MT1394
//元素频次
//请编写一个简单程序，输入10个整型元素，输出数组中每个元素出现的次数。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//依次输出元素频次，每个一行。



//#include<stdio.h>
//#define N 10
//int main()
//{
//    int a[N], i, j, o, count, bool_i;
//    for (i = 0; i < N; i++)
//    {
//        scanf("%d", &a[i]);
//    }
//    for (i = 0; i < N; i++)
//    {
//        count = 1;
//        for (j = i + 1; j < N; j++)
//        {
//            if (a[i] == a[j])
//            {
//                count++;
//            }
//        }
//        bool_i = 1;
//        for (o = 0; o < i; o++)
//        {
//            if (a[o] == a[i])
//            {
//                bool_i = 0;
//            }
//        }
//        if (bool_i)
//        {
//            printf("%d %d\n", a[i], count);
//        }
//    }
//    return 0;
//}





#include<stdio.h>
#include<stdbool.h>
#define N 10
// #define TRUE 1
// #define FALSE 0
int main()
{
    int a[N], i, j, o, count, flag;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 0; i < N; i++)
    {
        count = 1;
        for (j = i + 1; j < N; j++)
        {
            if (a[i] == a[j])
            {
                count++;
            }
        }
        flag = true;
        for (o = 0; o < i; o++)
        {
            if (a[o] == a[i])
            {
                flag = false;
            }
        }
        if (flag)
        {
            printf("%d %d\n", a[i], count);
        }
    }
    return 0;
}










//MT1395
//统计
//统计一个整型数组中不同元素出现的次数。
//
//格式
//输入格式：
//第一行输入数组元素个数N为整型，第二行输入元素，如样例所示。
//
//输出格式：
//输出为整型，前面是元素，后面是出现的次数，每种一行。


#include<stdio.h>
#include<stdbool.h>
int main()
{
    int N, i, j, o, count, flag;
    scanf("%d", &N);
    int a[N];
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 0; i < N; i++)
    {
        count = 1;
        for (j = i + 1; j < N; j++)
        {
            if (a[i] == a[j])
            {
                count++;
            }
        }
        flag = true;
        for (o = 0; o < i; o++)
        {
            if (a[o] == a[i])
            {
                flag = false;
            }
        }
        if (flag)
        {
            printf("%d %d\n", a[i], count);
        }
    }
    return 0;
}
















//MT1396
//排序吧
//定义一个长度为n的整型数组，输入n个数组元素的值，然后输出从小到大排序后数组元素。
//
//格式
//输入格式：
//输入整型，分2行输入。第一行输入n，第二行输入n个数组元素的值，空格分隔
//
//输出格式：
//输出整型，空格分隔


#include<stdio.h>
void BubbleSort(int a[], int size)
{
    int i, j, temp;
    for (i = 0; i < size - 1; i++)
    {
        for (j = 0; j < size - i - 1; j++)
        {
            if (a[j] > a[j + 1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}
int main()
{
    int n, i, size;
    scanf("%d", &n);
    int a[n];
    for (i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    size = sizeof(a) / sizeof(a[0]);
    BubbleSort(a, size);
    for (i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}






//MT1397
//选择排序
//输入10个整型元素，对数组进行选择排序，输出从小到大排序后的新数组。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//
//输出格式：
//输出整型，空格分隔。


#include<stdio.h>
int main()
{
    int arr[10] = { 0 };
    int min, temp = 0;
    for (int i = 0; i < 10; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (int i = 0; i < 9; i++)
    {
        min = i;
        for (int j = i + 1; j < 10; j++)
        {
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }
        temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}









//MT1398
//插入排序
//输入10个整型元素，对数组进行插入排序，输出从小到大排序后的新数组。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//
//输出格式：
//输出整型，空格分隔。
#include<stdio.h>
#define N 10
int main()
{
    int arr[N], i, j, key;
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (int i = 1; i < N; i++)
    {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
    for (int i = 0; i < N; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}







//MT1399
//冒泡排序
//输入10个整型元素，对数组进行冒泡排序，输出从小到大排序后的新数组。
//
//格式
//输入格式：
//输入整型，空格分隔。
//
//输出格式：
//输出整型，空格分隔。


#include<stdio.h>
#define N 10
int main()
{
    int a[N], i, j, temp;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    for (i = 0; i < N - 1; i++)
    {
        for (j = 0; j < N - i - 1; j++)
        {
            if (a[j] > a[j + 1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
    for (i = 0; i < N; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

//MT1515
//整型变量和它的指针
//定义一个整型变量和指针，让指针指向这个变量，通过指针输出变量的值。
//
//格式
//输入格式：
//输入整型
//
//输出格式：
//输出整型


#include<stdio.h>
int main()
{
    int x, * p;
    scanf("%d", &x);
    p = &x;
    printf("%d\n", *p);
    return 0;
}


//MT1516
//用指针交换2个数
//编写一个程序，输入2个整数，用指针指向他们，交换他们的值后输出。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型，空格分隔

#include<stdio.h>
int main()
{
    int temp, x1, x2;
    scanf("%d %d", &x1, &x2);
    int* p1 = &x1, * p2 = &x2;
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    printf("%d %d", x1, x2);
    return 0;
}


//MT1517
//顺序输出
//编写一个程序，输入3个整数，用指针方法指向他们， 将它们按由小到大的顺序输出。
//
//格式
//输入格式：
//输入整型，空格分隔
//
//输出格式：
//输出整型，空格分隔


#include<stdio.h>
int main()
{
    int a, b, c, * x, * y, * z;
    scanf("%d %d %d", &a, &b, &c);
    x = &a;
    y = &b;
    z = &c;
    if ((*x < *y) && (*y < *z))
    {
        printf("%d %d %d", *x, *y, *z);
    }
    else if ((*z < *y) && (*y < *x))
    {
        printf("%d %d %d", *z, *y, *x);
    }
    else if ((*y < *x) && (*x < *z))
    {
        printf("%d %d %d", *y, *x, *z);
    }
    else if ((*z < *x) && (*x < *y))
    {
        printf("%d %d %d", *z, *x, *y);
    }
    else if ((*x < *z) && (*z < *y))
    {
        printf("%d %d %d", *x, *z, *y);
    }
    else if ((*y < *z) && (*z < *x))
    {
        printf("%d %d %d", *y, *z, *x);
    }
    return 0;
}







//MT1519
//实型指针
//定义一个实型变量和指针，让指针指向这个变量，通过指针输出变量的值。
//
//格式
//输入格式：
//输入实型
//
//输出格式：
//输出实型



#include<stdio.h>
int main()
{
    double x, * p;
    scanf("%lf", &x);
    p = &x;
    printf("%lf\n", *p);
    return 0;
}



//MT1520
//字符型指针
//定义一个字符型变量和指针，让指针指向这个变量，通过指针输出变量的值。
//
//格式
//输入格式：
//输入字符型
//
//输出格式：
//输出字符型


#include<stdio.h>
int main()
{
    char x, * p;
    scanf("%c", &x);
    p = &x;
    printf("%c\n", *p);
    return 0;
}


//MT1533
#include<stdio.h>
#define N 10
int main()
{
    int a[N], i;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    int* p = a;
    for (i = 0; i < N; i++)
    {
        printf("%d ", *p++);
    }
    return 0;
}



//MT1534指针递增
//写一个使用指针递增方式访问数组a的元素的程序。数组长度为3，数组元素为1，2，3。
//格式
//输入格式：
//
//无
//输出格式：
//
//分行输出数组a的元素，数组为整型
#include<stdio.h>
int main()
{
    int a[3] = { 1, 2, 3 };
    int* p = a;
    for (int i = 0; i < 3; i++)
    {
        printf("a[%d]=%d\n", i, *p++);
    }
    return 0;
}


//MT1535间隔插入
//定义一个指向一维数组的指针，从键盘上输入10个数组元素，按后原来数组中，每两个元素之间插入一个1，输出新数组。
//格式
//输入格式：
//
//输入数组元素，整型，空格分隔。
//输出格式：
//
//输出整型，空格分隔。
// #include<stdio.h>
// int main() 
// { 
//     int a[19], i;
//     for (i=0;i<19;i++)
//     {
//         if (i % 2 == 1)
//         {
//             a[i] = 1;
//         }
//         else
//         {
//             scanf("%d", &a[i]);
//         }
//     }
//     int *p = a;
//     for (i=0;i<19;i++)
//     {
//         printf("%d ", *p++);
//     }
//     return 0; 
// }


//MT1538

// #include<stdio.h>
// #define N 10
// int main() 
// { 
//     int a[N], i;
//     for (i=0;i<N;i++)
//     {
//         scanf("%d", &a[i]);
//     }
//     int *p = a;
//     for (i=0;i<N;i++)
//     {
//         if (i % 2 == 0)
//         {
//             printf("%d ", *p++);
//         }
//         else
//         {
//             *p++;
//         }
//     }
//     return 0; 
// }

#include<stdio.h>
#define N 10
int main()
{
    int a[N], i;
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    int* p = a;
    for (i = 0; i < N / 2; i++)
    {
        printf("%d ", *p);
        p = p + 2;
    }
    return 0;

















//MT1455
//字符串输入输出方法II
//输入一个字符串，输出字符串。请用% s输入输出整个字符串。本题不考虑空格。
//
//格式
//输入格式：
//分2行输入。第一行输入字符串长度n，第二行输入字符串。
//
//输出格式：
//输出字符型




#include<stdio.h>
int main()
{
    int n;
    //char a[];  Error
    scanf("%d", &n);
    char a[n];
    scanf("%s", &a);
    printf("%s\n", a);
    return 0;
}














//MT1558
//新生命
//狼群新生了一只尊贵的艾尔法狼，请设计一个结构体，管理它的信息，信息包括名字，年龄，性别。
//
//输入艾尔法狼宝宝的信息，然后再输出他的信息。
//
//格式
//输入格式：
//输入名字性别为字符型，年龄整型
//
//输出格式：
//输出名字性别为字符型，年龄整型



#include<stdio.h>
struct information
{
    char name[50];
    int age;
    char sex;
} message;
int main()
{
    scanf("%s %d %c", message.name, &message.age, &message.sex);
    printf("%s %d %c\n", message.name, message.age, message.sex);
    return 0;
}



//MT1559
//幼儿园
//幼儿园开学了，请帮老师设计一个结构体，管理宝宝们的信息，信息包括姓名，年龄，性别。
//
//输入5个宝宝的信息，然后再输出他们的信息。
//
//格式
//输入格式：
//输入分5行，姓名性别为字符型，年龄整型
//
//输出格式：
//输出1行



#include<stdio.h>
struct information
{
    char name[50];
    int age;
    char sex;
};
int main()
{
    struct information baby1;
    struct information baby2;
    struct information baby3;
    struct information baby4;
    struct information baby5;

    scanf("%s %d %c", baby1.name, &baby1.age, &baby1.sex);
    scanf("%s %d %c", baby2.name, &baby2.age, &baby2.sex);
    scanf("%s %d %c", baby3.name, &baby3.age, &baby3.sex);
    scanf("%s %d %c", baby4.name, &baby4.age, &baby4.sex);
    scanf("%s %d %c", baby5.name, &baby5.age, &baby5.sex);

    printf("%s %d %c ", baby1.name, baby1.age, baby1.sex);
    printf("%s %d %c ", baby2.name, baby2.age, baby2.sex);
    printf("%s %d %c ", baby3.name, baby3.age, baby3.sex);
    printf("%s %d %c ", baby4.name, baby4.age, baby4.sex);
    printf("%s %d %c ", baby5.name, baby5.age, baby5.sex);
    return 0;
}


//MT1562
//谁是先锋
//攻城战要开始了，女王依依手里有4个黑骑士，女王依依要找出最强大的黑骑士作为先锋。
//
//请设计一个结构体，管理他们的信息，信息包括姓名，攻击力。
//
//输入他们信息，然后再输出先锋的信息。
//
//格式
//输入格式：
//输入分4行，姓名为字符型，攻击力整型
//
//输出格式：
//输出分4行


#include<stdio.h>
struct information
{
    char name[50];
    int attack_power;
};

int main()
{
    struct information Knight1;
    struct information Knight2;
    struct information Knight3;
    struct information Knight4;

    scanf("%s %d", Knight1.name, &Knight1.attack_power);
    scanf("%s %d", Knight2.name, &Knight2.attack_power);
    scanf("%s %d", Knight3.name, &Knight3.attack_power);
    scanf("%s %d", Knight4.name, &Knight4.attack_power);

    if ((Knight1.attack_power > Knight2.attack_power) && (Knight3.attack_power > Knight4.attack_power))
    {
        if (Knight1.attack_power > Knight3.attack_power)
        {
            printf("%s %d", Knight1.name, Knight1.attack_power);
        }
        else
        {
            printf("%s %d", Knight3.name, Knight3.attack_power);
        }
    }
    else if ((Knight1.attack_power < Knight2.attack_power) && (Knight3.attack_power < Knight4.attack_power))
    {
        if (Knight2.attack_power > Knight4.attack_power)
        {
            printf("%s %d", Knight2.name, Knight2.attack_power);
        }
        else
        {
            printf("%s %d", Knight4.name, Knight4.attack_power);
        }
    }
    else if ((Knight1.attack_power > Knight2.attack_power) && (Knight3.attack_power < Knight4.attack_power))
    {
        if (Knight1.attack_power > Knight4.attack_power)
        {
            printf("%s %d", Knight1.name, Knight1.attack_power);
        }
        else
        {
            printf("%s %d", Knight4.name, Knight4.attack_power);
        }
    }
    else if ((Knight1.attack_power < Knight2.attack_power) && (Knight3.attack_power > Knight4.attack_power))
    {
        if (Knight2.attack_power > Knight3.attack_power)
        {
            printf("%s %d", Knight2.name, Knight2.attack_power);
        }
        else
        {
            printf("%s %d", Knight3.name, Knight3.attack_power);
        }
    }
    return 0;
}



//MT1563
//谁是胆小鬼
//攻城战结束了，女王依依清点俘虏，发现跑掉了1个胆小的穴居人，女王依依要找出是谁跑掉了。斥候调查发现逃走的是一个攻击力最弱小的穴居人。
//
//请设计一个结构体，管理穴居人俘虏的信息，信息包括姓名，攻击力。
//
//输入4个俘虏的信息，然后再输出逃走的俘虏的信息。
//
//格式
//输入格式：
//输入分4行，姓名为字符型，攻击力整型
//
//输出格式：
//输出分4行




#include<stdio.h>
struct information
{
    char name[50];
    int attack_power;
};
int main()
{
    struct information people1;
    struct information people2;
    struct information people3;
    struct information people4;

    scanf("%s %d", people1.name, &people1.attack_power);
    scanf("%s %d", people2.name, &people2.attack_power);
    scanf("%s %d", people3.name, &people3.attack_power);
    scanf("%s %d", people4.name, &people4.attack_power);

    if ((people1.attack_power < people2.attack_power) && (people3.attack_power < people4.attack_power))
    {
        if (people1.attack_power < people3.attack_power)
        {
            printf("%s %d", people1.name, people1.attack_power);
        }
        else
        {
            printf("%s %d", people3.name, people3.attack_power);
        }
    }
    else if ((people1.attack_power > people2.attack_power) && (people3.attack_power > people4.attack_power))
    {
        if (people2.attack_power < people4.attack_power)
        {
            printf("%s %d", people2.name, people2.attack_power);
        }
        else
        {
            printf("%s %d", people4.name, people4.attack_power);
        }
    }
    else if ((people1.attack_power < people2.attack_power) && (people3.attack_power > people4.attack_power))
    {
        if (people1.attack_power < people4.attack_power)
        {
            printf("%s %d", people1.name, people1.attack_power);
        }
        else
        {
            printf("%s %d", people4.name, people4.attack_power);
        }
    }
    else if ((people1.attack_power > people2.attack_power) && (people3.attack_power < people4.attack_power))
    {
        if (people2.attack_power < people3.attack_power)
        {
            printf("%s %d", people2.name, people2.attack_power);
        }
        else
        {
            printf("%s %d", people3.name, people3.attack_power);
        }
    }
    return 0;
}


//MT1564
//编程好难
//小码哥买了3本编程书，他想先学最简单的，请帮他把最薄的书挑出来。 请设计一个结构体，管理书籍的信息，信息包括种类，书名（不含空格），页数。输入书籍的信息，然后再输出最薄的书信息。
//
//格式
//输入格式：
//按行输入种类，书名为字符型，价格整型
//
//输出格式：
//按行输出种类，书名为字符型，价格整型


#include<stdio.h>
struct Books
{
    char language[10];
    char name[30];
    int page;
};
int main()
{
    struct Books book1;
    struct Books book2;
    struct Books book3;

    scanf("%s %s %d", book1.language, book1.name, &book1.page);
    scanf("%s %s %d", book2.language, book2.name, &book2.page);
    scanf("%s %s %d", book3.language, book3.name, &book3.page);

    if (book1.page < book2.page && book1.page < book3.page)
    {
        printf("%s %s %d", book1.language, book1.name, book1.page);
    }
    else if (book2.page < book1.page && book2.page < book3.page)
    {
        printf("%s %s %d", book2.language, book2.name, book2.page);
    }
    else if (book3.page < book2.page && book3.page < book1.page)
    {
        printf("%s %s %d", book3.language, book3.name, book3.page);
    }

    return 0;
}


//MT1565
//长者
//输出结构体数组中年龄最大者的数据 ，请设计一个结构体， 信息包括名字，年龄 。输入5个人信息，然后再输出年龄最大的人的信息。
//
//格式
//输入格式：
//输入名字性别为字符型，年龄整型
//
//输出格式：
//输出名字性别为字符型，年龄整型


#include<stdio.h>
struct information
{
    char name[10];
    int age;
};
int* max(struct information* people_a, struct information* people_b);
int main()
{
    struct information people1;
    struct information people2;
    struct information people3;
    struct information people4;
    struct information people5;
    struct information* elder;

    scanf("%s %d", people1.name, &people1.age);
    scanf("%s %d", people2.name, &people2.age);
    scanf("%s %d", people3.name, &people3.age);
    scanf("%s %d", people4.name, &people4.age);
    scanf("%s %d", people5.name, &people5.age);

    elder = max(max(max(&people1, &people2), max(&people3, &people4)), &people5);

    printf("%s %d", elder->name, elder->age);
    return 0;
}

int* max(struct information* people_a, struct information* people_b)
{
    if (people_a->age > people_b->age)
    {
        return people_a;
    }
    else
    {
        return people_b;
    }
}


//MT1566
//幼者
//输出结构体数组中年龄最小者的数据 ，请设计一个结构体， 信息包括名字，年龄 。输入5个人信息，然后再输出年龄最小的人的信息。
//
//格式
//输入格式：
//输入名字性别为字符型，年龄整型
//
//输出格式：
//输出名字性别为字符型，年龄整型


#include<stdio.h>
struct information
{
    char name[10];
    int age;
};
int* min(struct information* people_a, struct information* people_b);
int main()
{
    struct information people1;
    struct information people2;
    struct information people3;
    struct information people4;
    struct information people5;
    struct information* young;

    scanf("%s %d", people1.name, &people1.age);
    scanf("%s %d", people2.name, &people2.age);
    scanf("%s %d", people3.name, &people3.age);
    scanf("%s %d", people4.name, &people4.age);
    scanf("%s %d", people5.name, &people5.age);

    young = min(min(min(&people1, &people2), min(&people3, &people4)), &people5);

    printf("%s %d", young->name, young->age);
    return 0;
}

int* min(struct information* people_a, struct information* people_b)
{
    if (people_a->age < people_b->age)
    {
        return people_a;
    }
    else
    {
        return people_b;
    }
}


//MT1567
//员工薪水
//有3个员工，从键盘输入数据，包括工号、姓名、薪水，工号薪水整型，姓名字符型，输出薪水最高的员工信息。不考虑非法输入等特殊情况。
//
//格式
//输入格式：
//每行输入一个员工的数据，空格分隔。
//
//输出格式：
//输出薪水最高的员工信息



#include<stdio.h>
struct information
{
    int job_number;
    char name[10];
    int salary;
};
int* max(struct information* employee_a, struct information* employee_b);
int main()
{
    struct information employee1;
    struct information employee2;
    struct information employee3;
    struct information* employee;

    scanf("%d %s %d", &employee1.job_number, employee1.name, &employee1.salary);
    scanf("%d %s %d", &employee2.job_number, employee2.name, &employee2.salary);
    scanf("%d %s %d", &employee3.job_number, employee3.name, &employee3.salary);

    employee = max(max(&employee1, &employee2), &employee3);

    printf("%d %s %d", employee->job_number, employee->name, employee->salary);
    return 0;
}
int* max(struct information* employee_a, struct information* employee_b)
{
    if (employee_a->salary > employee_b->salary)
    {
        return employee_a;
    }
    else
    {
        return employee_b;
    }
}


//MT1568
//学生成绩
//有3个学生，每个学生有3门课的成绩，从键盘输入数据，包括学号、姓名、三门课成绩，学号整型，姓名字符型，成绩实型，计算3门课程总平均成绩，以及平均分最高的学生信息。不考虑非法成绩等特殊情况。
//
//格式
//输入格式：
//每行输入一个学生的数据，空格分隔。
//
//输出格式：
//输出平均分最高的学生信息

#include<stdio.h>
struct information
{
    int student_number;
    char name[20];
    double course1;
    double course2;
    double course3;
};
int* ave_max(struct information* student_a, struct information* student_b);
int main()
{
    struct information student1;
    struct information student2;
    struct information student3;
    struct information* student;

    scanf("%d %s %lf %lf %lf", &student1.student_number, student1.name, &student1.course1, &student1.course2, &student1.course3);
    scanf("%d %s %lf %lf %lf", &student2.student_number, student2.name, &student2.course1, &student2.course2, &student2.course3);
    scanf("%d %s %lf %lf %lf", &student3.student_number, student3.name, &student3.course1, &student3.course2, &student3.course3);

    student = ave_max(ave_max(&student1, &student2), &student3);

    printf("%d %s %.0lf %.0lf %.0lf", student->student_number, student->name, student->course1, student->course2, student->course3);
    return 0;
}
int* ave_max(struct information* student_a, struct information* student_b)
{
    double ave_a, ave_b;
    ave_a = (student_a->course1 + student_a->course2 + student_a->course3) / 3.0;
    ave_b = (student_b->course1 + student_b->course2 + student_b->course3) / 3.0;
    if (ave_a > ave_b)
    {
        return student_a;
    }
    else
    {
        return student_b;
    }
}

//MT1572
//交网费
//小码哥又喜欢看电视又喜欢打电话聊天，每个月都要花掉很多网费。从键盘输入数据，包括第几季度、该季度网费、话费，其全部整型，计算小码哥今年花了多少钱。不考虑非法输入等特殊情况。
//
//格式
//输入格式：
//每行输入一组数据，空格分隔。
//
//输出格式：
//输出整型



#include<stdio.h>
struct data
{
    int quarter_number;
    int internet_charges;
    int electricity;
};
int main()
{
    struct data quarter1;
    struct data quarter2;
    struct data quarter3;
    struct data quarter4;
    int sum_charges;

    scanf("%d %d %d", &quarter1.quarter_number, &quarter1.internet_charges, &quarter1.electricity);
    scanf("%d %d %d", &quarter2.quarter_number, &quarter2.internet_charges, &quarter2.electricity);
    scanf("%d %d %d", &quarter3.quarter_number, &quarter3.internet_charges, &quarter3.electricity);
    scanf("%d %d %d", &quarter4.quarter_number, &quarter4.internet_charges, &quarter4.electricity);

    sum_charges = quarter1.internet_charges + quarter1.electricity + quarter2.internet_charges + quarter2.electricity + quarter3.internet_charges + quarter3.electricity + quarter4.internet_charges + quarter4.electricity;
    printf("%d", sum_charges);
    return 0;
}


//MT2001
//幸运的3
//你有
//�
//n个数，可以将它们两两匹配(即将两数首尾相连)，每个数只能使用一次，问匹配后最多有多少个
//3
//3的倍数（没有进行匹配的数不算）？
//
//格式
//输入格式：
//第一行一个
//�
//n，接下来
//�
//n个正整数。
//
//输出格式：
//输出最多有多少个
//3
//3的倍数.


#include<stdio.h>
int main()
{
    int n, i, temp;
    int z0 = 0, z1 = 0, z2 = 0, count = 0;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &temp);
        switch (temp % 3)
        {
        case 0:
            z0++;
            break;
        case 1:
            z1++;
            break;
        case 2:
            z2++;
            break;
        default:
            break;
        }
    }
    count += (z0 / 2);
    if (z1 > z2)
    {
        count += z2;
    }
    else if (z2 > z1)
    {
        count += z1;
    }
    else
    {
        count += z1;
    }
    printf("%d\n", count);
    return 0;
}


//MT2027
//一秒成零



#include<stdio.h>
int Steps(int n)
{
    int count = 0;
    while (n)
    {
        if (n % 2 == 0)
        {
            n /= 2;
            count++;
        }
        else
        {
            n--;
            count++;
        }
    }
    return count;
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d", Steps(n));
    return 0;
}


//MT2031
//排队
//课间休息做游戏，要求男孩们和女孩们排成一队，最初按照加入队伍的顺序排。然而，过了一会儿，站在女孩们前面的男孩们开始感到尴尬，下一秒，他们会让身后的女孩站到自己前面。
//
//让我们更精确地描述这个过程。假设队列中的位置由
//1
//1到
//�
//n的整数顺序编号，我们对位置号
//1
//1中的人首先进行操作。如果在时间
//�
//X，男孩站在第
//�
//i个位置，女孩站在第
//�
//+
//1
//i + 1个位置，然后下一秒，男孩女孩的位置会交换，也就是此时第
//�
//i个是女孩，第
//�
//+
//1
//i + 1个是男孩。时间是以秒为单位给出的。
//
//你现在知道孩子们的初始位置。确定队列在
//�
//T秒之后的排列方式。
//
//格式
//输入格式：
//第一行包含两个整数
//�
//n和
//�
//t，表示队列中的人数和队列将转换成需要查找的排列的时间；
//下一行输入一个字符串
//�
//s，
//�
//s仅由
//�
//B和
//�
//G构成（B表示男孩，G表示女孩）。
//
//输出格式：
//一个字符串，表示最后的队列。


#include<stdio.h>
int main()
{
    int n, t, i;
    char temp;
    scanf("%d %d", &n, &t);
    char a[n];
    scanf("%s", a);
    while (t)
    {
        for (i = 0; i < n; i++)
        {
            if (a[i] == 'B' && a[i + 1] == 'G')
            {
                temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
                i++;
            }
        }
        t--;
    }
    printf("%s", a);
    return 0;
}













//MC0143 比较器
#include<stdio.h>
#include<math.h>
int fun(int x, int y)
{
    int xy = pow((double)x, (double)y);
    int yx = pow((double)y, (double)x);
    if (xy > yx)
    {
        return 1;
    }
    else if (yx > xy)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}
int main()
{
    int x, y;
    scanf("%d %d", &x, &y);
    printf("%d\n", fun(x, y));
    return 0;
}

